/*

 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_templateInterpreter_x86_32.cpp.incl"

#define __ _masm->

#ifndef CC_INTERP

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

  // Note: There should be a minimal interpreter frame set up when stack

  // overflow occurs since we check explicitly for it now.

  //

#ifdef ASSERT

  { Label L;

    __ lea(rax, Address(rbp,

                frame::interpreter_frame_monitor_block_top_offset * wordSize));

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

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

  __ empty_FPU_stack();

  // setup parameters

  // ??? convention: expect aberrant index in register rbx,

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

  __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException), rax, rbx);

  return entry;

}

address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

  address entry = __ pc();

  // object is at TOS

  __ pop(rax);

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

  // happened

  __ empty_expression_stack();

  __ empty_FPU_stack();

  __ call_VM(noreg,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::throw_ClassCastException),

             rax);

  return entry;

}

// Arguments are: required type at TOS+4, failing object (or NULL) at TOS.

address TemplateInterpreterGenerator::generate_WrongMethodType_handler() {

  address entry = __ pc();

  __ pop(rbx);                  // actual failing object is at TOS

  __ pop(rax);                  // required type is at TOS+4

  __ verify_oop(rbx);

  __ verify_oop(rax);

  // Various method handle types use interpreter registers as temps.

  __ restore_bcp();

  __ restore_locals();

  // Expression stack must be empty before entering the VM for an exception.

  __ empty_expression_stack();

  __ empty_FPU_stack();

  __ call_VM(noreg,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::throw_WrongMethodTypeException),

             // pass required type, failing object (or NULL)

             rax, rbx);

  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

    __ pop(rbx);

  }

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

  __ empty_expression_stack();

  __ empty_FPU_stack();

  // setup parameters

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

  if (pass_oop) {

    __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), rax, rbx);

  } else {

    if (message != NULL) {

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

    } else {

      __ movptr(rbx, NULL_WORD);

    }

    __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), rax, rbx);

  }

  // 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) {

  TosState incoming_state = state;

  Label interpreter_entry;

  address compiled_entry = __ pc();

#ifdef COMPILER2

  // The FPU stack is clean if UseSSE >= 2 but must be cleaned in other cases

  if ((incoming_state == ftos && UseSSE < 1) || (incoming_state == dtos && UseSSE < 2)) {

    for (int i = 1; i < 8; i++) {

        __ ffree(i);

    }

  } else if (UseSSE < 2) {

    __ empty_FPU_stack();

  }

#endif

  if ((incoming_state == ftos && UseSSE < 1) || (incoming_state == dtos && UseSSE < 2)) {

    __ MacroAssembler::verify_FPU(1, "generate_return_entry_for compiled");

  } else {

    __ MacroAssembler::verify_FPU(0, "generate_return_entry_for compiled");

  }

  __ jmp(interpreter_entry, relocInfo::none);

  // emit a sentinel we can test for when converting an interpreter

  // entry point to a compiled entry point.

  __ a_long(Interpreter::return_sentinel);

  __ a_long((int)compiled_entry);

  address entry = __ pc();

  __ bind(interpreter_entry);

  // In SSE mode, interpreter returns FP results in xmm0 but they need

  // to end up back on the FPU so it can operate on them.

  if (incoming_state == ftos && UseSSE >= 1) {

    __ subptr(rsp, wordSize);

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

    __ fld_s(Address(rsp, 0));

    __ addptr(rsp, wordSize);

  } else if (incoming_state == dtos && UseSSE >= 2) {

    __ subptr(rsp, 2*wordSize);

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

    __ fld_d(Address(rsp, 0));

    __ addptr(rsp, 2*wordSize);

  }

  __ MacroAssembler::verify_FPU(state == ftos || state == dtos ? 1 : 0, "generate_return_entry_for in interpreter");

  // Restore stack bottom in case i2c adjusted stack

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

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

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

  __ restore_bcp();

  __ restore_locals();

  Label L_got_cache, L_giant_index;

  if (EnableInvokeDynamic) {

    __ cmpb(Address(rsi, 0), Bytecodes::_invokedynamic);

    __ jcc(Assembler::equal, L_giant_index);

  }

  __ get_cache_and_index_at_bcp(rbx, rcx, 1, sizeof(u2));

  __ bind(L_got_cache);

  __ movl(rbx, Address(rbx, rcx,

                    Address::times_ptr, constantPoolCacheOopDesc::base_offset() +

                    ConstantPoolCacheEntry::flags_offset()));

  __ andptr(rbx, 0xFF);

  __ lea(rsp, Address(rsp, rbx, Interpreter::stackElementScale()));

  __ dispatch_next(state, step);

  // out of the main line of code...

  if (EnableInvokeDynamic) {

    __ bind(L_giant_index);

    __ get_cache_and_index_at_bcp(rbx, rcx, 1, sizeof(u4));

    __ jmp(L_got_cache);

  }

  return entry;

}

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

  address entry = __ pc();

  // In SSE mode, FP results are in xmm0

  if (state == ftos && UseSSE > 0) {

    __ subptr(rsp, wordSize);

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

    __ fld_s(Address(rsp, 0));

    __ addptr(rsp, wordSize);

  } else if (state == dtos && UseSSE >= 2) {

    __ subptr(rsp, 2*wordSize);

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

    __ fld_d(Address(rsp, 0));

    __ addptr(rsp, 2*wordSize);

  }

  __ MacroAssembler::verify_FPU(state == ftos || state == dtos ? 1 : 0, "generate_deopt_entry_for in interpreter");

  // The stack is not extended by deopt but we must NULL last_sp as this

  // entry is like a "return".

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

  __ restore_bcp();

  __ restore_locals();

  // handle exceptions

  { Label L;

    const Register thread = rcx;

    __ get_thread(thread);

    __ cmpptr(Address(thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);

    __ 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    : // fall through

    case T_LONG   : // fall through

    case T_VOID   : i = 4; break;

    case T_FLOAT  : i = 5; break;  // have to treat float and double separately for SSE

    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;

}

address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {

  address entry = __ pc();

  switch (type) {

    case T_BOOLEAN: __ c2bool(rax);            break;

    case T_CHAR   : __ andptr(rax, 0xFFFF);    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_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) {

          // Load ST0

          __ fld_d(Address(rsp, 0));

          // Store as float and empty fpu stack

          __ fstp_s(Address(rsp, 0));

          // 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, 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

// rcx: invocation counter

//

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

    __ cmp32(rcx,

  }

}

void InterpreterGenerator::generate_counter_overflow(Label* do_continue) {

  // Asm interpreter on entry

  // rdi - locals

  // rsi - bcp

  // rbx, - method

  // rdx - cpool

  // rbp, - interpreter frame

  // C++ interpreter on entry

  // rsi - new interpreter state pointer

  // rbp - interpreter frame pointer

  // rbx - method

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

  // rbx, - method

  // rcx - rcvr (assuming there is one)

  // top of stack return address of interpreter caller

  // rsp - sender_sp

  // C++ interpreter only

  // rsi - previous interpreter state pointer

  const Address size_of_parameters(rbx, methodOopDesc::size_of_parameters_offset());

  // InterpreterRuntime::frequency_counter_overflow takes one argument

  // indicating if the counter overflow occurs at a backwards branch (non-NULL bcp).

  // 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).

  __ movptr(rax, (intptr_t)false);

  __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), rax);

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

  // Preserve invariant that rsi/rdi contain bcp/locals of sender frame

  // and jump to the interpreted entry.

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

}

void InterpreterGenerator::generate_stack_overflow_check(void) {

  // 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.

  //

  // Registers live on entry:

  //

  // Asm interpreter

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

  // rbx,: methodOop

  // destroyed on exit

  // rax,

  // NOTE:  since the additional locals are also always pushed (wasn't obvious in

  // generate_method_entry) so the guard should work for them too.

  //

  // monitor entry size: see picture of stack set (generate_method_entry) and frame_x86.hpp

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

  // total overhead size: entry_size + (saved rbp, thru 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

  Label after_frame_check_pop;

  __ push(rsi);

  const Register thread = rsi;

  __ get_thread(thread);

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

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

  // locals + overhead, in bytes

  __ lea(rax, Address(noreg, rdx, Interpreter::stackElementScale(), overhead_size));

#ifdef ASSERT

  Label stack_base_okay, stack_size_okay;