/*

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

#define __ _masm->

const int method_offset = frame::interpreter_frame_method_offset * wordSize;

const int bci_offset    = frame::interpreter_frame_bcx_offset    * wordSize;

const int locals_offset = frame::interpreter_frame_locals_offset * wordSize;

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

address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

  address entry = __ pc();

#ifdef ASSERT

  {

    Label L;

    __ leaq(rax, Address(rbp,

                         frame::interpreter_frame_monitor_block_top_offset *

                         wordSize));

    __ cmpq(rax, rsp); // rax = maximal rsp for current rbp (stack

                       // grows negative)

    __ jcc(Assembler::aboveEqual, L); // check if frame is complete

    __ stop ("interpreter frame not set up");

    __ bind(L);

  }

#endif // ASSERT

  // Restore bcp under the assumption that the current frame is still

  // interpreted

  __ restore_bcp();

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

  // exception happened

  __ empty_expression_stack();

  // throw exception

  __ call_VM(noreg,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::throw_StackOverflowError));

  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();

  // setup parameters

  // ??? convention: expect aberrant index in register ebx

  __ lea(c_rarg1, ExternalAddress((address)name));

  __ call_VM(noreg,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::

                              throw_ArrayIndexOutOfBoundsException),

             c_rarg1, rbx);

  return entry;

}

address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

  address entry = __ pc();

  // object is at TOS

  __ popq(c_rarg1);

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

  // exception happened

  __ empty_expression_stack();

  __ call_VM(noreg,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::

                              throw_ClassCastException),

             c_rarg1);

  return entry;

}

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();

  if (pass_oop) {

    // object is at TOS

    __ popq(c_rarg2);

  }

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

  // exception happened

  __ empty_expression_stack();

  // setup parameters

  __ lea(c_rarg1, ExternalAddress((address)name));

  if (pass_oop) {

    __ call_VM(rax, CAST_FROM_FN_PTR(address,

                                     InterpreterRuntime::

                                     create_klass_exception),

               c_rarg1, c_rarg2);

  } else {

    // kind of lame ExternalAddress can't take NULL because

    // external_word_Relocation will assert.

    if (message != NULL) {

      __ lea(c_rarg2, ExternalAddress((address)message));

    } else {

      __ movptr(c_rarg2, NULL_WORD);

    }

    __ call_VM(rax,

               CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception),

               c_rarg1, c_rarg2);

  }

  // throw exception

  __ jump(ExternalAddress(Interpreter::throw_exception_entry()));

  return entry;

}

address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {

  address entry = __ pc();

  // NULL last_sp until next java call

  __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);

  __ dispatch_next(state);

  return entry;

}

address TemplateInterpreterGenerator::generate_return_entry_for(TosState state,

                                                                int step) {

  // amd64 doesn't need to do anything special about compiled returns

  // to the interpreter so the code that exists on x86 to place a sentinel

  // here and the specialized cleanup code is not needed here.

  address entry = __ pc();

  // Restore stack bottom in case i2c adjusted stack

  __ movq(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize));

  // and NULL it as marker that esp is now tos until next java call

  __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);

  __ restore_bcp();

  __ restore_locals();

  __ get_cache_and_index_at_bcp(rbx, rcx, 1);

  __ movl(rbx, Address(rbx, rcx,

                       Address::times_8,

                       in_bytes(constantPoolCacheOopDesc::base_offset()) +

                       3 * wordSize));

  __ andl(rbx, 0xFF);

  if (TaggedStackInterpreter) __ shll(rbx, 1); // 2 slots per parameter.

  __ leaq(rsp, Address(rsp, rbx, Address::times_8));

  __ dispatch_next(state, step);

  return entry;

}

address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state,

                                                               int step) {

  address entry = __ pc();

  // NULL last_sp until next java call

  __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD);

  __ restore_bcp();

  __ restore_locals();

  // handle exceptions

  {

    Label L;

    __ cmpq(Address(r15_thread, Thread::pending_exception_offset()), (int) NULL);

    __ jcc(Assembler::zero, L);

    __ call_VM(noreg,

               CAST_FROM_FN_PTR(address,

                                InterpreterRuntime::throw_pending_exception));

    __ should_not_reach_here();

    __ bind(L);

  }

  __ dispatch_next(state, step);

  return entry;

}

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_LONG   : i = 5; break;

    case T_VOID   : i = 6; break;

    case T_FLOAT  : i = 7; break;

    case T_DOUBLE : i = 8; break;

    case T_OBJECT : i = 9; break;

    case T_ARRAY  : i = 9; break;

    default       : ShouldNotReachHere();

  }

  assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers,

         "index out of bounds");

  return i;

}

address TemplateInterpreterGenerator::generate_result_handler_for(

        BasicType type) {

  address entry = __ pc();

  switch (type) {

  case T_BOOLEAN: __ c2bool(rax);            break;

  case T_CHAR   : __ movzwl(rax, rax);       break;

  case T_BYTE   : __ sign_extend_byte(rax);  break;

  case T_SHORT  : __ sign_extend_short(rax); break;

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

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

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

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

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

  case T_OBJECT :

    // retrieve result from frame

    __ movq(rax, Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize));

    // and verify it

    __ verify_oop(rax);

    break;

  default       : ShouldNotReachHere();

  }

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

  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.table_for(vtos));

  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

//

// rbx: method

// ecx: invocation counter

//

void InterpreterGenerator::generate_counter_incr(

        Label* overflow,

        Label* profile_method,

        Label* profile_method_continue) {

  const Address invocation_counter(rbx,

                                   methodOopDesc::invocation_counter_offset() +

                                   InvocationCounter::counter_offset());

  const Address backedge_counter(rbx,

                                 methodOopDesc::backedge_counter_offset() +

                                 InvocationCounter::counter_offset());

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

    __ incrementl(Address(rbx,

                    methodOopDesc::interpreter_invocation_counter_offset()));

  }

  // Update standard invocation counters

  __ movl(rax, backedge_counter); // load backedge counter

  __ incrementl(rcx, InvocationCounter::count_increment);

  __ andl(rax, InvocationCounter::count_mask_value); // mask out the

                                                     // status bits

  __ movl(invocation_counter, rcx); // save invocation count

  __ addl(rcx, rax); // add both counters

  // profile_method is non-null only for interpreted method so

  // profile_method != NULL == !native_call

  if (ProfileInterpreter && profile_method != NULL) {

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

    __ cmp32(rcx, ExternalAddress((address)&InvocationCounter::InterpreterProfileLimit));

    __ jcc(Assembler::less, *profile_method_continue);

    // if no method data exists, go to profile_method

    __ test_method_data_pointer(rax, *profile_method);

  }

  __ cmp32(rcx, ExternalAddress((address)&InvocationCounter::InterpreterInvocationLimit));

  __ jcc(Assembler::aboveEqual, *overflow);

}

void InterpreterGenerator::generate_counter_overflow(Label* do_continue) {

  // Asm interpreter on entry

  // r14 - locals

  // r13 - bcp

  // rbx - method

  // edx - cpool --- DOES NOT APPEAR TO BE TRUE

  // rbp - interpreter frame

  // On return (i.e. jump to entry_point) [ back to invocation of interpreter ]

  // Everything as it was on entry

  // rdx is not restored. Doesn't appear to really be set.

  const Address size_of_parameters(rbx,

                                   methodOopDesc::size_of_parameters_offset());

  // InterpreterRuntime::frequency_counter_overflow takes two

  // arguments, the first (thread) is passed by call_VM, the second

  // indicates if the counter overflow occurs at a backwards branch

  // (NULL bcp).  We pass zero for it.  The call returns the address

  // of the verified entry point for the method or NULL if the

  // compilation did not complete (either went background or bailed

  // out).

  __ movl(c_rarg1, 0);

  __ call_VM(noreg,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::frequency_counter_overflow),

             c_rarg1);

  __ movq(rbx, Address(rbp, method_offset));   // restore methodOop

  // Preserve invariant that r13/r14 contain bcp/locals of sender frame

  // and jump to the interpreted entry.

  __ jmp(*do_continue, relocInfo::none);

}

// See if we've got enough room on the stack for locals plus overhead.

// The expression stack grows down incrementally, so the normal guard

// page mechanism will work for that.

//

// NOTE: Since the additional locals are also always pushed (wasn't

// obvious in generate_method_entry) so the guard should work for them

// too.

//

// Args:

//      rdx: number of additional locals this frame needs (what we must check)

//      rbx: methodOop

//

// Kills:

//      rax

void InterpreterGenerator::generate_stack_overflow_check(void) {

  // monitor entry size: see picture of stack set

  // (generate_method_entry) and frame_amd64.hpp

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

  // total overhead size: entry_size + (saved rbp through expr stack

  // bottom).  be sure to change this if you add/subtract anything

  // to/from the overhead area

  const int overhead_size =

    -(frame::interpreter_frame_initial_sp_offset * wordSize) + entry_size;

  const int page_size = os::vm_page_size();

  Label after_frame_check;

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

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

  // for the additional locals.

  __ cmpl(rdx, (page_size - overhead_size) / Interpreter::stackElementSize());

  __ jcc(Assembler::belowEqual, after_frame_check);

  // compute rsp as if this were going to be the last frame on

  // the stack before the red zone

  const Address stack_base(r15_thread, Thread::stack_base_offset());

  const Address stack_size(r15_thread, Thread::stack_size_offset());

  // locals + overhead, in bytes

  __ movq(rax, rdx);

  __ shll(rax, Interpreter::logStackElementSize()); // 2 slots per parameter.

  __ addq(rax, overhead_size);

#ifdef ASSERT

  Label stack_base_okay, stack_size_okay;

  // verify that thread stack base is non-zero

  __ cmpq(stack_base, 0);

  __ jcc(Assembler::notEqual, stack_base_okay);

  __ stop("stack base is zero");

  __ bind(stack_base_okay);

  // verify that thread stack size is non-zero

  __ cmpq(stack_size, 0);

  __ jcc(Assembler::notEqual, stack_size_okay);

  __ stop("stack size is zero");

  __ bind(stack_size_okay);

#endif

  // Add stack base to locals and subtract stack size

  __ addq(rax, stack_base);

  __ subq(rax, stack_size);

  // add in the red and yellow zone sizes

  __ addq(rax, (StackRedPages + StackYellowPages) * page_size);

  // check against the current stack bottom

  __ cmpq(rsp, rax);

  __ jcc(Assembler::above, after_frame_check);

  __ popq(rax); // get return address

  __ jump(ExternalAddress(Interpreter::throw_StackOverflowError_entry()));

  // all done with frame size check

  __ bind(after_frame_check);

}

// Allocate monitor and lock method (asm interpreter)

//

// Args:

//      rbx: methodOop

//      r14: locals

//

// Kills:

//      rax

//      c_rarg0, c_rarg1, c_rarg2, c_rarg3, ...(param regs)

//      rscratch1, rscratch2 (scratch regs)

void InterpreterGenerator::lock_method(void) {

  // synchronize method

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

  const Address monitor_block_top(

        rbp,

        frame::interpreter_frame_monitor_block_top_offset * wordSize);

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

#ifdef ASSERT

  {

    Label L;

    __ movl(rax, access_flags);

    __ testl(rax, JVM_ACC_SYNCHRONIZED);

    __ jcc(Assembler::notZero, L);

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

    __ bind(L);

  }

#endif // ASSERT

  // get synchronization object

  {

    const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() +

                              Klass::java_mirror_offset_in_bytes();

    Label done;

    __ movl(rax, access_flags);

    __ testl(rax, JVM_ACC_STATIC);

    // get receiver (assume this is frequent case)

    __ movq(rax, Address(r14, Interpreter::local_offset_in_bytes(0)));

    __ jcc(Assembler::zero, done);

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

    __ movq(rax, Address(rax,

                         constantPoolOopDesc::pool_holder_offset_in_bytes()));

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

#ifdef ASSERT

    {

      Label L;

      __ testq(rax, rax);

      __ jcc(Assembler::notZero, L);

      __ stop("synchronization object is NULL");

      __ bind(L);

    }

#endif // ASSERT

    __ bind(done);

  }

  // add space for monitor & lock

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

  __ movq(monitor_block_top, rsp);  // set new monitor block top

  // store object

  __ movq(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax);

  __ movq(c_rarg1, rsp); // object address

  __ lock_object(c_rarg1);

}

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

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

//

// Args:

//      rax: return address

//      rbx: methodOop

//      r14: pointer to locals

//      r13: sender sp

//      rdx: cp cache

void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {

  // initialize fixed part of activation frame

  __ pushq(rax);       // save return address

  __ enter();          // save old & set new rbp

  __ pushq(r13);       // set sender sp

  __ pushq((int)NULL_WORD); // leave last_sp as null

  __ movq(r13, Address(rbx, methodOopDesc::const_offset()));      // get constMethodOop

  __ leaq(r13, Address(r13, constMethodOopDesc::codes_offset())); // get codebase

  __ pushq(rbx);       // save methodOop

  if (ProfileInterpreter) {

    Label method_data_continue;

    __ movq(rdx, Address(rbx, in_bytes(methodOopDesc::method_data_offset())));

    __ testq(rdx, rdx);

    __ jcc(Assembler::zero, method_data_continue);

    __ addq(rdx, in_bytes(methodDataOopDesc::data_offset()));

    __ bind(method_data_continue);

    __ pushq(rdx);     // set the mdp (method data pointer)

  } else {

    __ pushq(0);

  }

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

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

  __ pushq(rdx); // set constant pool cache

  __ pushq(r14); // set locals pointer

  if (native_call) {

    __ pushq(0); // no bcp

  } else {

    __ pushq(r13); // set bcp

  }