/*

 * Copyright (c) 2008, 2018, 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 "precompiled.hpp"

#include "asm/assembler.hpp"

#include "asm/macroAssembler.inline.hpp"

#include "interpreter/bytecodeHistogram.hpp"

#include "interpreter/interp_masm.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/templateInterpreterGenerator.hpp"

#include "interpreter/templateTable.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 "prims/methodHandles.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/align.hpp"

#include "utilities/debug.hpp"

#include "utilities/macros.hpp"

// Size of interpreter code.  Increase if too small.  Interpreter will

// fail with a guarantee ("not enough space for interpreter generation");

// if too small.

// Run with +PrintInterpreter to get the VM to print out the size.

// Max size with JVMTI

int TemplateInterpreter::InterpreterCodeSize = 180 * 1024;

#define __ _masm->

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

address TemplateInterpreterGenerator::generate_slow_signature_handler() {

  address entry = __ pc();

  // callee-save register for saving LR, shared with generate_native_entry

  const Register Rsaved_ret_addr = Rtmp_save0;

  __ mov(Rsaved_ret_addr, LR);

  __ mov(R1, Rmethod);

  __ mov(R2, Rlocals);

  __ mov(R3, SP);

  // Safer to save R9 (when scratched) since callers may have been

  // written assuming R9 survives. This is suboptimal but

  // probably not important for this slow case call site.

  // Note for R9 saving: slow_signature_handler may copy register

  // arguments above the current SP (passed as R3). It is safe for

  // call_VM to use push and pop to protect additional values on the

  // stack if needed.

  __ call_VM(CAST_FROM_FN_PTR(address, InterpreterRuntime::slow_signature_handler), true /* save R9 if needed*/);

  __ add(SP, SP, wordSize);     // Skip R0

  __ pop(RegisterSet(R1, R3));  // Load arguments passed in registers

#ifdef __ABI_HARD__

  // Few alternatives to an always-load-FP-registers approach:

  // - parse method signature to detect FP arguments

  // - keep a counter/flag on a stack indicationg number of FP arguments in the method.

  // The later has been originally implemented and tested but a conditional path could

  // eliminate any gain imposed by avoiding 8 double word loads.

  __ fldmiad(SP, FloatRegisterSet(D0, 8), writeback);

#endif // __ABI_HARD__

  __ ret(Rsaved_ret_addr);

  return entry;

}

//

// Various method entries (that c++ and asm interpreter agree upon)

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

//

//

// Abstract method entry

// Attempt to execute abstract method. Throw exception

address TemplateInterpreterGenerator::generate_abstract_entry(void) {

  address entry_point = __ pc();

  __ empty_expression_stack();

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

  DEBUG_ONLY(STOP("generate_abstract_entry");) // Should not reach here

  return entry_point;

}

address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::MethodKind kind) {

  if (!InlineIntrinsics) return NULL; // Generate a vanilla entry

  // TODO: ARM

  return NULL;

  address entry_point = __ pc();

  STOP("generate_math_entry");

  return entry_point;

}

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;

    __ sub(Rtemp, FP, - frame::interpreter_frame_monitor_block_top_offset * wordSize);

    __ cmp(SP, Rtemp);  // Rtemp = maximal SP for current FP,

                        //  (stack grows negative)

    __ b(L, ls); // 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));

  __ should_not_reach_here();

  return entry;

}

address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler() {

  address entry = __ pc();

  // index is in R4_ArrayIndexOutOfBounds_index

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

  __ empty_expression_stack();

  // setup parameters

  // Array expected in R1.

  __ mov(R2, R4_ArrayIndexOutOfBounds_index);

  __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException), R1, R2);

  __ nop(); // to avoid filling CPU pipeline with invalid instructions

  __ nop();

  __ should_not_reach_here();

  return entry;

}

address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

  address entry = __ pc();

  // object is in R2_ClassCastException_obj

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

  // happened

  __ empty_expression_stack();

  __ mov(R1, R2_ClassCastException_obj);

  __ call_VM(noreg,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::throw_ClassCastException),

             R1);

  __ should_not_reach_here();

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

  InlinedString Lname(name);

  InlinedString Lmessage(message);

  if (pass_oop) {

    // object is at TOS

    __ pop_ptr(R2);

  }

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

  __ empty_expression_stack();

  // setup parameters

  __ ldr_literal(R1, Lname);

  if (pass_oop) {

    __ call_VM(Rexception_obj, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), R1, R2);

  } else {

    if (message != NULL) {

      __ ldr_literal(R2, Lmessage);

    } else {

      __ mov(R2, 0);

    }

    __ call_VM(Rexception_obj, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), R1, R2);

  }

  // throw exception

  __ b(Interpreter::throw_exception_entry());

  __ nop(); // to avoid filling CPU pipeline with invalid instructions

  __ nop();

  __ bind_literal(Lname);

  if (!pass_oop && (message != NULL)) {

    __ bind_literal(Lmessage);

  }

  return entry;

}

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

  address entry = __ pc();

  __ interp_verify_oop(R0_tos, state, __FILE__, __LINE__);

  // Restore stack bottom in case i2c adjusted stack

  __ ldr(SP, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize));

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

  __ mov(Rtemp, (int)NULL_WORD);

  __ str(Rtemp, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize));

  __ restore_method();

  __ restore_bcp();

  __ restore_dispatch();

  __ restore_locals();

  const Register Rcache = R2_tmp;

  const Register Rindex = R3_tmp;

  __ get_cache_and_index_at_bcp(Rcache, Rindex, 1, index_size);

  __ add(Rtemp, Rcache, AsmOperand(Rindex, lsl, LogBytesPerWord));

  __ ldrb(Rtemp, Address(Rtemp, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()));

  __ check_stack_top();

  __ add(Rstack_top, Rstack_top, AsmOperand(Rtemp, lsl, Interpreter::logStackElementSize));

  __ convert_retval_to_tos(state);

 __ check_and_handle_popframe();

 __ check_and_handle_earlyret();

  __ dispatch_next(state, step);

  return entry;

}

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

  address entry = __ pc();

  __ interp_verify_oop(R0_tos, state, __FILE__, __LINE__);

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

  // entry is like a "return".

  __ mov(Rtemp, 0);

  __ str(Rtemp, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize));

  __ restore_method();

  __ restore_bcp();

  __ restore_dispatch();

  __ restore_locals();

  // handle exceptions

  { Label L;

    __ ldr(Rtemp, Address(Rthread, Thread::pending_exception_offset()));

    __ cbz(Rtemp, L);

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

    __ should_not_reach_here();

    __ bind(L);

  }

  if (continuation == NULL) {

    __ dispatch_next(state, step);

  } else {

    __ jump_to_entry(continuation);

  }

  return entry;

}

address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {

  address entry = __ pc();

  switch (type) {

  case T_CHAR    : /* Nothing to do */  break;

  case T_BYTE    : /* Nothing to do */  break;

  case T_SHORT   : /* Nothing to do */  break;

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

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

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

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

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

  case T_BOOLEAN : __ c2bool(R0);       break;

  case T_OBJECT  :

    __ ldr(R0, Address(FP, frame::interpreter_frame_oop_temp_offset * wordSize));

    __ verify_oop(R0);

    break;

  default        : __ should_not_reach_here(); break;

  }

  __ ret();

  return entry;

}

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

  address entry = __ pc();

  __ push(state);

  __ call_VM(noreg, runtime_entry);

  // load current bytecode

  __ ldrb(R3_bytecode, Address(Rbcp));

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

//

// In: Rmethod.

//

// Uses R0, R1, Rtemp.

//

void TemplateInterpreterGenerator::generate_counter_incr(Label* overflow,

                                                 Label* profile_method,

                                                 Label* profile_method_continue) {

  Label done;

  const Register Rcounters = Rtemp;

  const Address invocation_counter(Rcounters,

                MethodCounters::invocation_counter_offset() +

                InvocationCounter::counter_offset());

  // Note: In tiered we increment either counters in MethodCounters* 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(R1_tmp, Address(Rmethod, Method::method_data_offset()));

      __ cbz(R1_tmp, no_mdo);

      // Increment counter in the MDO

      const Address mdo_invocation_counter(R1_tmp,

                    in_bytes(MethodData::invocation_counter_offset()) +

                    in_bytes(InvocationCounter::counter_offset()));

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

      __ increment_mask_and_jump(mdo_invocation_counter, increment, mask, R0_tmp, Rtemp, eq, overflow);

      __ b(done);

    }

    __ bind(no_mdo);

    __ get_method_counters(Rmethod, Rcounters, done);

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

    __ increment_mask_and_jump(invocation_counter, increment, mask, R0_tmp, R1_tmp, eq, overflow);

    __ bind(done);

  } else { // not TieredCompilation

    const Address backedge_counter(Rcounters,

                  MethodCounters::backedge_counter_offset() +

                  InvocationCounter::counter_offset());

    const Register Ricnt = R0_tmp;  // invocation counter

    const Register Rbcnt = R1_tmp;  // backedge counter

    __ get_method_counters(Rmethod, Rcounters, done);

    if (ProfileInterpreter) {

      const Register Riic = R1_tmp;

      __ ldr_s32(Riic, Address(Rcounters, MethodCounters::interpreter_invocation_counter_offset()));

      __ add(Riic, Riic, 1);

      __ str_32(Riic, Address(Rcounters, MethodCounters::interpreter_invocation_counter_offset()));

    }

    // Update standard invocation counters

    __ ldr_u32(Ricnt, invocation_counter);

    __ ldr_u32(Rbcnt, backedge_counter);

    __ add(Ricnt, Ricnt, InvocationCounter::count_increment);

    __ bic(Rbcnt, Rbcnt, ~InvocationCounter::count_mask_value); // mask out the status bits

    __ str_32(Ricnt, invocation_counter);            // save invocation count

    __ add(Ricnt, Ricnt, Rbcnt);                     // add both counters

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

    // profile_method != NULL == !native_call

    // BytecodeInterpreter only calls for native so code is elided.

    if (ProfileInterpreter && profile_method != NULL) {

      assert(profile_method_continue != NULL, "should be non-null");

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

      // Reuse R1_tmp as we don't need backedge counters anymore.

      Address profile_limit(Rcounters, in_bytes(MethodCounters::interpreter_profile_limit_offset()));

      __ ldr_s32(R1_tmp, profile_limit);

      __ cmp_32(Ricnt, R1_tmp);

      __ b(*profile_method_continue, lt);

      // if no method data exists, go to profile_method

      __ test_method_data_pointer(R1_tmp, *profile_method);

    }

    Address invoke_limit(Rcounters, in_bytes(MethodCounters::interpreter_invocation_limit_offset()));

    __ ldr_s32(R1_tmp, invoke_limit);

    __ cmp_32(Ricnt, R1_tmp);

    __ b(*overflow, hs);

    __ bind(done);

  }

}

void TemplateInterpreterGenerator::generate_counter_overflow(Label& do_continue) {

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

  __ mov(R1, (int)false);

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

  // jump to the interpreted entry.

  __ b(do_continue);

}

void TemplateInterpreterGenerator::generate_stack_overflow_check(void) {

  // Check if we've got enough room on the stack for

  //  - overhead;

  //  - locals;

  //  - expression stack.

  //

  // Registers on entry:

  //

  // R3 = number of additional locals

  // Rthread

  // Rmethod

  // Registers used: R0, R1, R2, Rtemp.

  const Register Radditional_locals = R3;

  const Register RmaxStack = R2;

  // monitor entry size

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

  // total overhead size: entry_size + (saved registers, thru expr stack bottom).

  // be sure to change this if you add/subtract anything to/from the overhead area

  const int overhead_size = (frame::sender_sp_offset - frame::interpreter_frame_initial_sp_offset)*wordSize + entry_size;

  // Pages reserved for VM runtime calls and subsequent Java calls.

  const int reserved_pages = JavaThread::stack_shadow_zone_size();

  // Thread::stack_size() includes guard pages, and they should not be touched.

  const int guard_pages = JavaThread::stack_guard_zone_size();

  __ ldr(R0, Address(Rthread, Thread::stack_base_offset()));

  __ ldr(R1, Address(Rthread, Thread::stack_size_offset()));

  __ ldr(Rtemp, Address(Rmethod, Method::const_offset()));

  __ ldrh(RmaxStack, Address(Rtemp, ConstMethod::max_stack_offset()));

  __ sub_slow(Rtemp, SP, overhead_size + reserved_pages + guard_pages + Method::extra_stack_words());

  // reserve space for additional locals

  __ sub(Rtemp, Rtemp, AsmOperand(Radditional_locals, lsl, Interpreter::logStackElementSize));

  // stack size

  __ sub(R0, R0, R1);

  // reserve space for expression stack

  __ sub(Rtemp, Rtemp, AsmOperand(RmaxStack, lsl, Interpreter::logStackElementSize));

  __ cmp(Rtemp, R0);

  __ mov(SP, Rsender_sp, ls);  // restore SP

  __ b(StubRoutines::throw_StackOverflowError_entry(), ls);

}

// Allocate monitor and lock method (asm interpreter)

//

void TemplateInterpreterGenerator::lock_method() {

  // synchronize method

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

  assert ((entry_size % StackAlignmentInBytes) == 0, "should keep stack alignment");

  #ifdef ASSERT

    { Label L;

      __ ldr_u32(Rtemp, Address(Rmethod, Method::access_flags_offset()));