/*

 * Copyright 2007-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/_cppInterpreter_x86.cpp.incl"

#ifdef CC_INTERP

// Routine exists to make tracebacks look decent in debugger

// while we are recursed in the frame manager/c++ interpreter.

// We could use an address in the frame manager but having

// frames look natural in the debugger is a plus.

extern "C" void RecursiveInterpreterActivation(interpreterState istate )

{

  //

  ShouldNotReachHere();

}

#define __ _masm->

#define STATE(field_name) (Address(state, byte_offset_of(BytecodeInterpreter, field_name)))

Label fast_accessor_slow_entry_path;  // fast accessor methods need to be able to jmp to unsynchronized

                                      // c++ interpreter entry point this holds that entry point label.

// default registers for state and sender_sp

// state and sender_sp are the same on 32bit because we have no choice.

// state could be rsi on 64bit but it is an arg reg and not callee save

// so r13 is better choice.

const Register state = NOT_LP64(rsi) LP64_ONLY(r13);

const Register sender_sp_on_entry = NOT_LP64(rsi) LP64_ONLY(r13);

// NEEDED for JVMTI?

// address AbstractInterpreter::_remove_activation_preserving_args_entry;

static address unctrap_frame_manager_entry  = NULL;

static address deopt_frame_manager_return_atos  = NULL;

static address deopt_frame_manager_return_btos  = NULL;

static address deopt_frame_manager_return_itos  = NULL;

static address deopt_frame_manager_return_ltos  = NULL;

static address deopt_frame_manager_return_ftos  = NULL;

static address deopt_frame_manager_return_dtos  = NULL;

static address deopt_frame_manager_return_vtos  = NULL;

int AbstractInterpreter::BasicType_as_index(BasicType type) {

  int i = 0;

  switch (type) {

    case T_BOOLEAN: i = 0; break;

    case T_CHAR   : i = 1; break;

    case T_BYTE   : i = 2; break;

    case T_SHORT  : i = 3; break;

    case T_INT    : i = 4; break;

    case T_VOID   : i = 5; break;

    case T_FLOAT  : i = 8; break;

    case T_LONG   : i = 9; break;

    case T_DOUBLE : i = 6; break;

    case T_OBJECT : // fall through

    case T_ARRAY  : i = 7; break;

    default       : ShouldNotReachHere();

  }

  assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers, "index out of bounds");

  return i;

}

// Is this pc anywhere within code owned by the interpreter?

// This only works for pc that might possibly be exposed to frame

// walkers. It clearly misses all of the actual c++ interpreter

// implementation

bool CppInterpreter::contains(address pc)            {

    return (_code->contains(pc) ||

            pc == CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation));

}

address CppInterpreterGenerator::generate_result_handler_for(BasicType type) {

  address entry = __ pc();

  switch (type) {

    case T_BOOLEAN: __ c2bool(rax);            break;

    case T_CHAR   : __ andl(rax, 0xFFFF);      break;

    case T_BYTE   : __ sign_extend_byte (rax); break;

    case T_SHORT  : __ sign_extend_short(rax); break;

    case T_VOID   : // fall thru

    case T_LONG   : // fall thru

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

    case T_DOUBLE :

    case T_FLOAT  :

      {

        const Register t = InterpreterRuntime::SignatureHandlerGenerator::temp();

        __ pop(t);                            // remove return address first

        // Must return a result for interpreter or compiler. In SSE

        // mode, results are returned in xmm0 and the FPU stack must

        // be empty.

        if (type == T_FLOAT && UseSSE >= 1) {

#ifndef _LP64

          // Load ST0

          __ fld_d(Address(rsp, 0));

          // Store as float and empty fpu stack

          __ fstp_s(Address(rsp, 0));

#endif // !_LP64

          // and reload

          __ movflt(xmm0, Address(rsp, 0));

        } else if (type == T_DOUBLE && UseSSE >= 2 ) {

          __ movdbl(xmm0, Address(rsp, 0));

        } else {

          // restore ST0

          __ fld_d(Address(rsp, 0));

        }

        // and pop the temp

        __ addptr(rsp, 2 * wordSize);

        __ push(t);                            // restore return address

      }

      break;

    case T_OBJECT :

      // retrieve result from frame

      __ movptr(rax, STATE(_oop_temp));

      // and verify it

      __ verify_oop(rax);

      break;

    default       : ShouldNotReachHere();

  }

  __ ret(0);                                   // return from result handler

  return entry;

}

// tosca based result to c++ interpreter stack based result.

// Result goes to top of native stack.

#undef EXTEND  // SHOULD NOT BE NEEDED

address CppInterpreterGenerator::generate_tosca_to_stack_converter(BasicType type) {

  // A result is in the tosca (abi result) from either a native method call or compiled

  // code. Place this result on the java expression stack so C++ interpreter can use it.

  address entry = __ pc();

  const Register t = InterpreterRuntime::SignatureHandlerGenerator::temp();

  __ pop(t);                            // remove return address first

  switch (type) {

    case T_VOID:

       break;

    case T_BOOLEAN:

#ifdef EXTEND

      __ c2bool(rax);

#endif

      __ push(rax);

      break;

    case T_CHAR   :

#ifdef EXTEND

      __ andl(rax, 0xFFFF);

#endif

      __ push(rax);

      break;

    case T_BYTE   :

#ifdef EXTEND

      __ sign_extend_byte (rax);

#endif

      __ push(rax);

      break;

    case T_SHORT  :

#ifdef EXTEND

      __ sign_extend_short(rax);

#endif

      __ push(rax);

      break;

    case T_LONG    :

      __ push(rdx);                             // pushes useless junk on 64bit

      __ push(rax);

      break;

    case T_INT    :

      __ push(rax);

      break;

    case T_FLOAT  :

      // Result is in ST(0)/xmm0

      __ subptr(rsp, wordSize);

      if ( UseSSE < 1) {

        __ fstp_s(Address(rsp, 0));

      } else {

        __ movflt(Address(rsp, 0), xmm0);

      }

      break;

    case T_DOUBLE  :

      __ subptr(rsp, 2*wordSize);

      if ( UseSSE < 2 ) {

        __ fstp_d(Address(rsp, 0));

      } else {

        __ movdbl(Address(rsp, 0), xmm0);

      }

      break;

    case T_OBJECT :

      __ verify_oop(rax);                      // verify it

      __ push(rax);

      break;

    default       : ShouldNotReachHere();

  }

  __ jmp(t);                                   // return from result handler

  return entry;

}

address CppInterpreterGenerator::generate_stack_to_stack_converter(BasicType type) {

  // A result is in the java expression stack of the interpreted method that has just

  // returned. Place this result on the java expression stack of the caller.

  //

  // The current interpreter activation in rsi/r13 is for the method just returning its

  // result. So we know that the result of this method is on the top of the current

  // execution stack (which is pre-pushed) and will be return to the top of the caller

  // stack. The top of the callers stack is the bottom of the locals of the current

  // activation.

  // Because of the way activation are managed by the frame manager the value of rsp is

  // below both the stack top of the current activation and naturally the stack top

  // of the calling activation. This enable this routine to leave the return address

  // to the frame manager on the stack and do a vanilla return.

  //

  // On entry: rsi/r13 - interpreter state of activation returning a (potential) result

  // On Return: rsi/r13 - unchanged

  //            rax - new stack top for caller activation (i.e. activation in _prev_link)

  //

  // Can destroy rdx, rcx.

  //

  address entry = __ pc();

  const Register t = InterpreterRuntime::SignatureHandlerGenerator::temp();

  switch (type) {

    case T_VOID:

      __ movptr(rax, STATE(_locals));                                   // pop parameters get new stack value

      __ addptr(rax, wordSize);                                         // account for prepush before we return

      break;

    case T_FLOAT  :

    case T_BOOLEAN:

    case T_CHAR   :

    case T_BYTE   :

    case T_SHORT  :

    case T_INT    :

      // 1 word result

      __ movptr(rdx, STATE(_stack));

      __ movptr(rax, STATE(_locals));                                   // address for result

      __ movl(rdx, Address(rdx, wordSize));                             // get result

      __ movptr(Address(rax, 0), rdx);                                  // and store it

      break;

    case T_LONG    :

    case T_DOUBLE  :

      // return top two words on current expression stack to caller's expression stack

      // The caller's expression stack is adjacent to the current frame manager's intepretState

      // except we allocated one extra word for this intepretState so we won't overwrite it

      // when we return a two word result.

      __ movptr(rax, STATE(_locals));                                   // address for result

      __ movptr(rcx, STATE(_stack));

      __ subptr(rax, wordSize);                                         // need addition word besides locals[0]

      __ movptr(rdx, Address(rcx, 2*wordSize));                         // get result word (junk in 64bit)

      __ movptr(Address(rax, wordSize), rdx);                           // and store it

      __ movptr(rdx, Address(rcx, wordSize));                           // get result word

      __ movptr(Address(rax, 0), rdx);                                  // and store it

      break;

    case T_OBJECT :

      __ movptr(rdx, STATE(_stack));

      __ movptr(rax, STATE(_locals));                                   // address for result

      __ movptr(rdx, Address(rdx, wordSize));                           // get result

      __ verify_oop(rdx);                                               // verify it

      __ movptr(Address(rax, 0), rdx);                                  // and store it

      break;

    default       : ShouldNotReachHere();

  }

  __ ret(0);

  return entry;

}

address CppInterpreterGenerator::generate_stack_to_native_abi_converter(BasicType type) {

  // A result is in the java expression stack of the interpreted method that has just

  // returned. Place this result in the native abi that the caller expects.

  //

  // Similar to generate_stack_to_stack_converter above. Called at a similar time from the

  // frame manager execept in this situation the caller is native code (c1/c2/call_stub)

  // and so rather than return result onto caller's java expression stack we return the

  // result in the expected location based on the native abi.

  // On entry: rsi/r13 - interpreter state of activation returning a (potential) result

  // On Return: rsi/r13 - unchanged

  // Other registers changed [rax/rdx/ST(0) as needed for the result returned]

  address entry = __ pc();

  switch (type) {

    case T_VOID:

       break;

    case T_BOOLEAN:

    case T_CHAR   :

    case T_BYTE   :

    case T_SHORT  :

    case T_INT    :

      __ movptr(rdx, STATE(_stack));                                    // get top of stack

      __ movl(rax, Address(rdx, wordSize));                             // get result word 1

      break;

    case T_LONG    :

      __ movptr(rdx, STATE(_stack));                                    // get top of stack

      __ movptr(rax, Address(rdx, wordSize));                           // get result low word

      NOT_LP64(__ movl(rdx, Address(rdx, 2*wordSize));)                 // get result high word

      break;

    case T_FLOAT  :

      __ movptr(rdx, STATE(_stack));                                    // get top of stack

      if ( UseSSE >= 1) {

        __ movflt(xmm0, Address(rdx, wordSize));

      } else {

        __ fld_s(Address(rdx, wordSize));                               // pushd float result

      }

      break;

    case T_DOUBLE  :

      __ movptr(rdx, STATE(_stack));                                    // get top of stack

      if ( UseSSE > 1) {

        __ movdbl(xmm0, Address(rdx, wordSize));

      } else {

        __ fld_d(Address(rdx, wordSize));                               // push double result

      }

      break;

    case T_OBJECT :

      __ movptr(rdx, STATE(_stack));                                    // get top of stack

      __ movptr(rax, Address(rdx, wordSize));                           // get result word 1

      __ verify_oop(rax);                                               // verify it

      break;

    default       : ShouldNotReachHere();

  }

  __ ret(0);

  return entry;

}

address CppInterpreter::return_entry(TosState state, int length) {

  // make it look good in the debugger

  return CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation);

}

address CppInterpreter::deopt_entry(TosState state, int length) {

  address ret = NULL;

  if (length != 0) {

    switch (state) {

      case atos: ret = deopt_frame_manager_return_atos; break;

      case btos: ret = deopt_frame_manager_return_btos; break;

      case ctos:

      case stos:

      case itos: ret = deopt_frame_manager_return_itos; break;

      case ltos: ret = deopt_frame_manager_return_ltos; break;

      case ftos: ret = deopt_frame_manager_return_ftos; break;

      case dtos: ret = deopt_frame_manager_return_dtos; break;

      case vtos: ret = deopt_frame_manager_return_vtos; break;

    }

  } else {

    ret = unctrap_frame_manager_entry;  // re-execute the bytecode ( e.g. uncommon trap)

  }

  assert(ret != NULL, "Not initialized");

  return ret;

}

// C++ Interpreter

void CppInterpreterGenerator::generate_compute_interpreter_state(const Register state,

                                                                 const Register locals,

                                                                 const Register sender_sp,

                                                                 bool native) {

  // On entry the "locals" argument points to locals[0] (or where it would be in case no locals in

  // a static method). "state" contains any previous frame manager state which we must save a link

  // to in the newly generated state object. On return "state" is a pointer to the newly allocated

  // state object. We must allocate and initialize a new interpretState object and the method

  // expression stack. Because the returned result (if any) of the method will be placed on the caller's

  // expression stack and this will overlap with locals[0] (and locals[1] if double/long) we must

  // be sure to leave space on the caller's stack so that this result will not overwrite values when

  // locals[0] and locals[1] do not exist (and in fact are return address and saved rbp). So when

  // we are non-native we in essence ensure that locals[0-1] exist. We play an extra trick in

  // non-product builds and initialize this last local with the previous interpreterState as

  // this makes things look real nice in the debugger.

  // State on entry

  // Assumes locals == &locals[0]

  // Assumes state == any previous frame manager state (assuming call path from c++ interpreter)

  // Assumes rax = return address

  // rcx == senders_sp

  // rbx == method

  // Modifies rcx, rdx, rax

  // Returns:

  // state == address of new interpreterState

  // rsp == bottom of method's expression stack.

  const Address const_offset      (rbx, methodOopDesc::const_offset());

  // On entry sp is the sender's sp. This includes the space for the arguments

  // that the sender pushed. If the sender pushed no args (a static) and the

  // caller returns a long then we need two words on the sender's stack which

  // are not present (although when we return a restore full size stack the

  // space will be present). If we didn't allocate two words here then when

  // we "push" the result of the caller's stack we would overwrite the return

  // address and the saved rbp. Not good. So simply allocate 2 words now

  // just to be safe. This is the "static long no_params() method" issue.

  // See Lo.java for a testcase.

  // We don't need this for native calls because they return result in

  // register and the stack is expanded in the caller before we store

  // the results on the stack.

  if (!native) {

#ifdef PRODUCT

    __ subptr(rsp, 2*wordSize);

#else /* PRODUCT */

    __ push((int32_t)NULL_WORD);

    __ push(state);                         // make it look like a real argument

#endif /* PRODUCT */

  }

  // Now that we are assure of space for stack result, setup typical linkage

  __ push(rax);

  __ enter();

  __ mov(rax, state);                                  // save current state

  __ lea(rsp, Address(rsp, -(int)sizeof(BytecodeInterpreter)));

  __ mov(state, rsp);

  // rsi/r13 == state/locals rax == prevstate

  // initialize the "shadow" frame so that use since C++ interpreter not directly

  // recursive. Simpler to recurse but we can't trim expression stack as we call

  // new methods.

  __ movptr(STATE(_locals), locals);                    // state->_locals = locals()

  __ movptr(STATE(_self_link), state);                  // point to self

  __ movptr(STATE(_prev_link), rax);                    // state->_link = state on entry (NULL or previous state)

  __ movptr(STATE(_sender_sp), sender_sp);              // state->_sender_sp = sender_sp

#ifdef _LP64

  __ movptr(STATE(_thread), r15_thread);                // state->_bcp = codes()

#else

  __ get_thread(rax);                                   // get vm's javathread*

  __ movptr(STATE(_thread), rax);                       // state->_bcp = codes()

#endif // _LP64

  __ movptr(rdx, Address(rbx, methodOopDesc::const_offset())); // get constantMethodOop

  __ lea(rdx, Address(rdx, constMethodOopDesc::codes_offset())); // get code base

  if (native) {

    __ movptr(STATE(_bcp), (int32_t)NULL_WORD);         // state->_bcp = NULL

  } else {

    __ movptr(STATE(_bcp), rdx);                        // state->_bcp = codes()

  }

  __ xorptr(rdx, rdx);

  __ movptr(STATE(_oop_temp), rdx);                     // state->_oop_temp = NULL (only really needed for native)

  __ movptr(STATE(_mdx), rdx);                          // state->_mdx = NULL

  __ movptr(rdx, Address(rbx, methodOopDesc::constants_offset()));

  __ movptr(rdx, Address(rdx, constantPoolOopDesc::cache_offset_in_bytes()));

  __ movptr(STATE(_constants), rdx);                    // state->_constants = constants()

  __ movptr(STATE(_method), rbx);                       // state->_method = method()

  __ movl(STATE(_msg), (int32_t) BytecodeInterpreter::method_entry);   // state->_msg = initial method entry

  __ movptr(STATE(_result._to_call._callee), (int32_t) NULL_WORD); // state->_result._to_call._callee_callee = NULL

  __ movptr(STATE(_monitor_base), rsp);                 // set monitor block bottom (grows down) this would point to entry [0]

                                                        // entries run from -1..x where &monitor[x] ==

  {

    // Must not attempt to lock method until we enter interpreter as gc won't be able to find the

    // initial frame. However we allocate a free monitor so we don't have to shuffle the expression stack

    // immediately.

    // synchronize method

    const Address access_flags      (rbx, methodOopDesc::access_flags_offset());

    const int entry_size            = frame::interpreter_frame_monitor_size() * wordSize;

    Label not_synced;

    __ movl(rax, access_flags);

    __ testl(rax, JVM_ACC_SYNCHRONIZED);

    __ jcc(Assembler::zero, not_synced);

    // Allocate initial monitor and pre initialize it

    // get synchronization object

    Label done;

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

    __ movl(rax, access_flags);

    __ testl(rax, JVM_ACC_STATIC);

    __ movptr(rax, Address(locals, 0));                   // get receiver (assume this is frequent case)

    __ jcc(Assembler::zero, done);

    __ movptr(rax, Address(rbx, methodOopDesc::constants_offset()));

    __ movptr(rax, Address(rax, constantPoolOopDesc::pool_holder_offset_in_bytes()));

    __ movptr(rax, Address(rax, mirror_offset));

    __ bind(done);

    // add space for monitor & lock

    __ subptr(rsp, entry_size);                                           // add space for a monitor entry

    __ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax); // store object

    __ bind(not_synced);

  }

  __ movptr(STATE(_stack_base), rsp);                                     // set expression stack base ( == &monitors[-count])

  if (native) {

    __ movptr(STATE(_stack), rsp);                                        // set current expression stack tos

    __ movptr(STATE(_stack_limit), rsp);

  } else {

    __ subptr(rsp, wordSize);                                             // pre-push stack

    __ movptr(STATE(_stack), rsp);                                        // set current expression stack tos

    // compute full expression stack limit

    const Address size_of_stack    (rbx, methodOopDesc::max_stack_offset());