/*

 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.

 * Copyright (c) 2014, Red Hat 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

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

 * questions.

 *

 */

#include "precompiled.hpp"

#include "asm/macroAssembler.hpp"

#include "interpreter/bytecodeHistogram.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/interp_masm.hpp"

#include "interpreter/templateInterpreterGenerator.hpp"

#include "interpreter/templateTable.hpp"

#include "interpreter/bytecodeTracer.hpp"

#include "oops/arrayOop.hpp"

#include "oops/methodData.hpp"

#include "oops/method.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "runtime/arguments.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/synchronizer.hpp"

#include "runtime/timer.hpp"

#include "runtime/vframeArray.hpp"

#include "utilities/debug.hpp"

#include <sys/types.h>

#ifndef PRODUCT

#include "oops/method.hpp"

#endif // !PRODUCT

#ifdef BUILTIN_SIM

#include "../../../../../../simulator/simulator.hpp"

#endif

#define __ _masm->

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

extern "C" void entry(CodeBuffer*);

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

address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

  address entry = __ pc();

#ifdef ASSERT

  {

    Label L;

    __ ldr(rscratch1, Address(rfp,

                       frame::interpreter_frame_monitor_block_top_offset *

                       wordSize));

    __ mov(rscratch2, sp);

    __ cmp(rscratch1, rscratch2); // maximal rsp for current rfp (stack

                           // grows negative)

    __ br(Assembler::HS, 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 r1

  __ movw(c_rarg2, r1);

  __ mov(c_rarg1, (address)name);

  __ call_VM(noreg,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::

                              throw_ArrayIndexOutOfBoundsException),

             c_rarg1, c_rarg2);

  return entry;

}

address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

  address entry = __ pc();

  // object is at TOS

  __ pop(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

    __ pop(c_rarg2);

  }

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

  // exception happened

  __ empty_expression_stack();

  // setup parameters

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

  if (pass_oop) {

    __ call_VM(r0, 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, Address((address)message));

    } else {

      __ mov(c_rarg2, NULL_WORD);

    }

    __ call_VM(r0,

               CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception),

               c_rarg1, c_rarg2);

  }

  // throw exception

  __ b(address(Interpreter::throw_exception_entry()));

  return entry;

}

address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {

  address entry = __ pc();

  // NULL last_sp until next java call

  __ str(zr, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));

  __ dispatch_next(state);

  return entry;

}

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

  address entry = __ pc();

  // Restore stack bottom in case i2c adjusted stack

  __ ldr(esp, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));

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

  __ str(zr, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));

  __ restore_bcp();

  __ restore_locals();

  __ restore_constant_pool_cache();

  __ get_method(rmethod);

  // Pop N words from the stack

  __ get_cache_and_index_at_bcp(r1, r2, 1, index_size);

  __ ldr(r1, Address(r1, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()));

  __ andr(r1, r1, ConstantPoolCacheEntry::parameter_size_mask);

  __ add(esp, esp, r1, Assembler::LSL, 3);

  // Restore machine SP

  __ ldr(rscratch1, Address(rmethod, Method::const_offset()));

  __ ldrh(rscratch1, Address(rscratch1, ConstMethod::max_stack_offset()));

  __ add(rscratch1, rscratch1, frame::interpreter_frame_monitor_size() + 2);

  __ ldr(rscratch2,

         Address(rfp, frame::interpreter_frame_initial_sp_offset * wordSize));

  __ sub(rscratch1, rscratch2, rscratch1, ext::uxtw, 3);

  __ andr(sp, rscratch1, -16);

#ifndef PRODUCT

  // tell the simulator that the method has been reentered

  if (NotifySimulator) {

    __ notify(Assembler::method_reentry);

  }

#endif

  __ get_dispatch();

  __ dispatch_next(state, step);

  return entry;

}

address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state,

                                                               int step) {

  address entry = __ pc();

  __ restore_bcp();

  __ restore_locals();

  __ restore_constant_pool_cache();

  __ get_method(rmethod);

#if INCLUDE_JVMCI

  // Check if we need to take lock at entry of synchronized method.

  if (UseJVMCICompiler) {

    Label L;

    __ ldr(rscratch1, Address(rthread, Thread::pending_exception_offset()));

    __ cbz(rscratch1, L);

    // Clear flag.

    __ strb(zr, Address(rthread, JavaThread::pending_monitorenter_offset()));

    // Take lock.

    lock_method();

    __ bind(L);

  }

#endif

  // handle exceptions

  {

    Label L;

    __ ldr(rscratch1, Address(rthread, Thread::pending_exception_offset()));

    __ cbz(rscratch1, L);

    __ call_VM(noreg,

               CAST_FROM_FN_PTR(address,

                                InterpreterRuntime::throw_pending_exception));

    __ should_not_reach_here();

    __ bind(L);

  }

  __ get_dispatch();

  // Calculate stack limit

  __ ldr(rscratch1, Address(rmethod, Method::const_offset()));

  __ ldrh(rscratch1, Address(rscratch1, ConstMethod::max_stack_offset()));

  __ add(rscratch1, rscratch1, frame::interpreter_frame_monitor_size() + 2);

  __ ldr(rscratch2,

         Address(rfp, frame::interpreter_frame_initial_sp_offset * wordSize));

  __ sub(rscratch1, rscratch2, rscratch1, ext::uxtx, 3);

  __ andr(sp, rscratch1, -16);

  // Restore expression stack pointer

  __ ldr(esp, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));

  // NULL last_sp until next java call

  __ str(zr, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));

  __ dispatch_next(state, step);

  return entry;

}

address TemplateInterpreterGenerator::generate_result_handler_for(

        BasicType type) {

    address entry = __ pc();

  switch (type) {

  case T_BOOLEAN: __ uxtb(r0, r0);        break;

  case T_CHAR   : __ uxth(r0, r0);       break;

  case T_BYTE   : __ sxtb(r0, r0);        break;

  case T_SHORT  : __ sxth(r0, r0);        break;

  case T_INT    : __ uxtw(r0, r0);        break;  // FIXME: We almost certainly don't need this

  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

    __ ldr(r0, Address(rfp, frame::interpreter_frame_oop_temp_offset*wordSize));

    // and verify it

    __ verify_oop(r0);

    break;

  default       : ShouldNotReachHere();

  }

  __ ret(lr);                                  // 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);

  __ membar(Assembler::AnyAny);

  __ 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

//

// rmethod: method

//

void TemplateInterpreterGenerator::generate_counter_incr(

        Label* overflow,

        Label* profile_method,

        Label* profile_method_continue) {

  Label done;

  // Note: In tiered we increment either counters in Method* or in MDO depending if we're profiling or not.

  if (TieredCompilation) {

    int increment = InvocationCounter::count_increment;

    Label no_mdo;

    if (ProfileInterpreter) {

      // Are we profiling?

      __ ldr(r0, Address(rmethod, Method::method_data_offset()));

      __ cbz(r0, no_mdo);

      // Increment counter in the MDO

      const Address mdo_invocation_counter(r0, in_bytes(MethodData::invocation_counter_offset()) +

                                                in_bytes(InvocationCounter::counter_offset()));

      const Address mask(r0, in_bytes(MethodData::invoke_mask_offset()));

      __ increment_mask_and_jump(mdo_invocation_counter, increment, mask, rscratch1, rscratch2, false, Assembler::EQ, overflow);

      __ b(done);

    }

    __ bind(no_mdo);

    // Increment counter in MethodCounters

    const Address invocation_counter(rscratch2,

                  MethodCounters::invocation_counter_offset() +

                  InvocationCounter::counter_offset());

    __ get_method_counters(rmethod, rscratch2, done);

    const Address mask(rscratch2, in_bytes(MethodCounters::invoke_mask_offset()));

    __ increment_mask_and_jump(invocation_counter, increment, mask, rscratch1, r1, false, Assembler::EQ, overflow);

    __ bind(done);

  } else { // not TieredCompilation

    const Address backedge_counter(rscratch2,

                  MethodCounters::backedge_counter_offset() +

                  InvocationCounter::counter_offset());

    const Address invocation_counter(rscratch2,

                  MethodCounters::invocation_counter_offset() +

                  InvocationCounter::counter_offset());

    __ get_method_counters(rmethod, rscratch2, done);

    if (ProfileInterpreter) { // %%% Merge this into MethodData*

      __ ldrw(r1, Address(rscratch2, MethodCounters::interpreter_invocation_counter_offset()));

      __ addw(r1, r1, 1);

      __ strw(r1, Address(rscratch2, MethodCounters::interpreter_invocation_counter_offset()));

    }

    // Update standard invocation counters

    __ ldrw(r1, invocation_counter);

    __ ldrw(r0, backedge_counter);

    __ addw(r1, r1, InvocationCounter::count_increment);

    __ andw(r0, r0, InvocationCounter::count_mask_value);

    __ strw(r1, invocation_counter);

    __ addw(r0, r0, r1);                // 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

      __ ldr(rscratch2, Address(rmethod, Method::method_counters_offset()));

      __ ldrw(rscratch2, Address(rscratch2, in_bytes(MethodCounters::interpreter_profile_limit_offset())));

      __ cmpw(r0, rscratch2);

      __ br(Assembler::LT, *profile_method_continue);

      // if no method data exists, go to profile_method

      __ test_method_data_pointer(rscratch2, *profile_method);

    }

    {

      __ ldr(rscratch2, Address(rmethod, Method::method_counters_offset()));

      __ ldrw(rscratch2, Address(rscratch2, in_bytes(MethodCounters::interpreter_invocation_limit_offset())));

      __ cmpw(r0, rscratch2);

      __ br(Assembler::HS, *overflow);

    }

    __ bind(done);

  }

}

void TemplateInterpreterGenerator::generate_counter_overflow(Label& do_continue) {

  // Asm interpreter on entry

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

  // Everything as it was on entry

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

  __ mov(c_rarg1, 0);

  __ call_VM(noreg,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::frequency_counter_overflow),

             c_rarg1);

  __ b(do_continue);

}

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

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

//      rmethod: Method*

//

// Kills:

//      r0

void TemplateInterpreterGenerator::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.

  //

  // Note that we use SUBS rather than CMP here because the immediate

  // field of this instruction may overflow.  SUBS can cope with this

  // because it is a macro that will expand to some number of MOV

  // instructions and a register operation.

  __ subs(rscratch1, r3, (page_size - overhead_size) / Interpreter::stackElementSize);

  __ br(Assembler::LS, 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(rthread, Thread::stack_base_offset());

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

  // locals + overhead, in bytes

  __ mov(r0, overhead_size);

  __ add(r0, r0, r3, Assembler::LSL, Interpreter::logStackElementSize);  // 2 slots per parameter.

  __ ldr(rscratch1, stack_base);

  __ ldr(rscratch2, stack_size);

#ifdef ASSERT

  Label stack_base_okay, stack_size_okay;

  // verify that thread stack base is non-zero

  __ cbnz(rscratch1, stack_base_okay);

  __ stop("stack base is zero");

  __ bind(stack_base_okay);

  // verify that thread stack size is non-zero

  __ cbnz(rscratch2, stack_size_okay);

  __ stop("stack size is zero");

  __ bind(stack_size_okay);

#endif

  // Add stack base to locals and subtract stack size

  __ sub(rscratch1, rscratch1, rscratch2); // Stack limit

  __ add(r0, r0, rscratch1);

  // Use the bigger size for banging.

  const int max_bang_size = MAX2(JavaThread::stack_shadow_zone_size(),

                                 JavaThread::stack_red_zone_size() + JavaThread::stack_yellow_zone_size());

  // add in the red and yellow zone sizes

  __ add(r0, r0, max_bang_size * 2);

  // check against the current stack bottom

  __ cmp(sp, r0);

  __ br(Assembler::HI, after_frame_check);

  // Remove the incoming args, peeling the machine SP back to where it

  // was in the caller.  This is not strictly necessary, but unless we

  // do so the stack frame may have a garbage FP; this ensures a

  // correct call stack that we can always unwind.  The ANDR should be

  // unnecessary because the sender SP in r13 is always aligned, but

  // it doesn't hurt.

  __ andr(sp, r13, -16);

  // Note: the restored frame is not necessarily interpreted.

  // Use the shared runtime version of the StackOverflowError.

  assert(StubRoutines::throw_StackOverflowError_entry() != NULL, "stub not yet generated");

  __ far_jump(RuntimeAddress(StubRoutines::throw_StackOverflowError_entry()));

  // all done with frame size check

  __ bind(after_frame_check);

}

// Allocate monitor and lock method (asm interpreter)

//

// Args:

//      rmethod: Method*

//      rlocals: locals

//

// Kills:

//      r0

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