/*

 * Copyright (c) 1997, 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/macroAssembler.inline.hpp"

#include "gc/shared/barrierSetAssembler.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 "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/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

// The sethi() instruction generates lots more instructions when shell

// stack limit is unlimited, so that's why this is much bigger.

int TemplateInterpreter::InterpreterCodeSize = 260 * K;

// Generation of Interpreter

//

// The TemplateInterpreterGenerator generates the interpreter into Interpreter::_code.

#define __ _masm->

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

// LP64 passes floating point arguments in F1, F3, F5, etc. instead of

// O0, O1, O2 etc..

// Doubles are passed in D0, D2, D4

// We store the signature of the first 16 arguments in the first argument

// slot because it will be overwritten prior to calling the native

// function, with the pointer to the JNIEnv.

// If LP64 there can be up to 16 floating point arguments in registers

// or 6 integer registers.

address TemplateInterpreterGenerator::generate_slow_signature_handler() {

  enum {

    non_float  = 0,

    float_sig  = 1,

    double_sig = 2,

    sig_mask   = 3

  };

  address entry = __ pc();

  Argument argv(0, true);

  // We are in the jni transition frame. Save the last_java_frame corresponding to the

  // outer interpreter frame

  //

  __ set_last_Java_frame(FP, noreg);

  // make sure the interpreter frame we've pushed has a valid return pc

  __ mov(O7, I7);

  __ mov(Lmethod, G3_scratch);

  __ mov(Llocals, G4_scratch);

  __ save_frame(0);

  __ mov(G2_thread, L7_thread_cache);

  __ add(argv.address_in_frame(), O3);

  __ mov(G2_thread, O0);

  __ mov(G3_scratch, O1);

  __ call(CAST_FROM_FN_PTR(address, InterpreterRuntime::slow_signature_handler), relocInfo::runtime_call_type);

  __ delayed()->mov(G4_scratch, O2);

  __ mov(L7_thread_cache, G2_thread);

  __ reset_last_Java_frame();

  // load the register arguments (the C code packed them as varargs)

  Address Sig = argv.address_in_frame();        // Argument 0 holds the signature

  __ ld_ptr( Sig, G3_scratch );                   // Get register argument signature word into G3_scratch

  __ mov( G3_scratch, G4_scratch);

  __ srl( G4_scratch, 2, G4_scratch);             // Skip Arg 0

  Label done;

  for (Argument ldarg = argv.successor(); ldarg.is_float_register(); ldarg = ldarg.successor()) {

    Label NonFloatArg;

    Label LoadFloatArg;

    Label LoadDoubleArg;

    Label NextArg;

    Address a = ldarg.address_in_frame();

    __ andcc(G4_scratch, sig_mask, G3_scratch);

    __ br(Assembler::zero, false, Assembler::pt, NonFloatArg);

    __ delayed()->nop();

    __ cmp(G3_scratch, float_sig );

    __ br(Assembler::equal, false, Assembler::pt, LoadFloatArg);

    __ delayed()->nop();

    __ cmp(G3_scratch, double_sig );

    __ br(Assembler::equal, false, Assembler::pt, LoadDoubleArg);

    __ delayed()->nop();

    __ bind(NonFloatArg);

    // There are only 6 integer register arguments!

    if ( ldarg.is_register() )

      __ ld_ptr(ldarg.address_in_frame(), ldarg.as_register());

    else {

    // Optimization, see if there are any more args and get out prior to checking

    // all 16 float registers.  My guess is that this is rare.

    // If is_register is false, then we are done the first six integer args.

      __ br_null_short(G4_scratch, Assembler::pt, done);

    }

    __ ba(NextArg);

    __ delayed()->srl( G4_scratch, 2, G4_scratch );

    __ bind(LoadFloatArg);

    __ ldf( FloatRegisterImpl::S, a, ldarg.as_float_register(), 4);

    __ ba(NextArg);

    __ delayed()->srl( G4_scratch, 2, G4_scratch );

    __ bind(LoadDoubleArg);

    __ ldf( FloatRegisterImpl::D, a, ldarg.as_double_register() );

    __ ba(NextArg);

    __ delayed()->srl( G4_scratch, 2, G4_scratch );

    __ bind(NextArg);

  }

  __ bind(done);

  __ ret();

  __ delayed()->restore(O0, 0, Lscratch);  // caller's Lscratch gets the result handler

  return entry;

}

void TemplateInterpreterGenerator::generate_counter_overflow(Label& Lcontinue) {

  // Generate code to initiate compilation on the counter overflow.

  // InterpreterRuntime::frequency_counter_overflow takes two arguments,

  // the first indicates if the counter overflow occurs at a backwards branch (NULL bcp)

  // and the second is only used when the first is true.  We pass zero for both.

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

  __ set((int)false, O2);

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

  // returns verified_entry_point or NULL

  // we ignore it in any case

  __ ba_short(Lcontinue);

}

// End of helpers

// Various method entries

// Abstract method entry

// Attempt to execute abstract method. Throw exception

//

address TemplateInterpreterGenerator::generate_abstract_entry(void) {

  address entry = __ pc();

  // abstract method entry

  // throw exception

  __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodErrorWithMethod), G5_method);

  // the call_VM checks for exception, so we should never return here.

  __ should_not_reach_here();

  return entry;

}

void TemplateInterpreterGenerator::save_native_result(void) {

  // result potentially in O0/O1: save it across calls

  const Address& l_tmp = InterpreterMacroAssembler::l_tmp;

  // result potentially in F0/F1: save it across calls

  const Address& d_tmp = InterpreterMacroAssembler::d_tmp;

  // save and restore any potential method result value around the unlocking operation

  __ stf(FloatRegisterImpl::D, F0, d_tmp);

  __ stx(O0, l_tmp);

}

void TemplateInterpreterGenerator::restore_native_result(void) {

  const Address& l_tmp = InterpreterMacroAssembler::l_tmp;

  const Address& d_tmp = InterpreterMacroAssembler::d_tmp;

  // Restore any method result value

  __ ldf(FloatRegisterImpl::D, d_tmp, F0);

  __ ldx(l_tmp, O0);

}

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

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

  __ empty_expression_stack();

  // load exception object

  __ set((intptr_t)name, G3_scratch);

  if (pass_oop) {

    __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), G3_scratch, Otos_i);

  } else {

    __ set((intptr_t)message, G4_scratch);

    __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), G3_scratch, G4_scratch);

  }

  // throw exception

  assert(Interpreter::throw_exception_entry() != NULL, "generate it first");

  AddressLiteral thrower(Interpreter::throw_exception_entry());

  __ jump_to(thrower, G3_scratch);

  __ delayed()->nop();

  return entry;

}

address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

  address entry = __ pc();

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

  // happened

  __ empty_expression_stack();

  // load exception object

  __ call_VM(Oexception,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::throw_ClassCastException),

             Otos_i);

  __ should_not_reach_here();

  return entry;

}

address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler() {

  address entry = __ pc();

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

  __ empty_expression_stack();

  // Pass the array to create more detailed exceptions.

  // convention: expect aberrant index in register G3_scratch, then shuffle the

  // index to G4_scratch for the VM call

  __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException), G3_scratch, Otos_i);

  __ should_not_reach_here();

  return entry;

}

address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

  address entry = __ pc();

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

  __ empty_expression_stack();

  __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_StackOverflowError));

  __ should_not_reach_here();

  return entry;

}

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

  address entry = __ pc();

  if (state == atos) {

    __ profile_return_type(O0, G3_scratch, G1_scratch);

  }

  // The callee returns with the stack possibly adjusted by adapter transition

  // We remove that possible adjustment here.

  // All interpreter local registers are untouched. Any result is passed back

  // in the O0/O1 or float registers. Before continuing, the arguments must be

  // popped from the java expression stack; i.e., Lesp must be adjusted.

  __ mov(Llast_SP, SP);   // Remove any adapter added stack space.

  const Register cache = G3_scratch;

  const Register index  = G1_scratch;

  __ get_cache_and_index_at_bcp(cache, index, 1, index_size);

  const Register flags = cache;

  __ ld_ptr(cache, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset(), flags);

  const Register parameter_size = flags;

  __ and3(flags, ConstantPoolCacheEntry::parameter_size_mask, parameter_size);  // argument size in words

  __ sll(parameter_size, Interpreter::logStackElementSize, parameter_size);     // each argument size in bytes

  __ add(Lesp, parameter_size, Lesp);                                           // pop arguments

  __ check_and_handle_popframe(Gtemp);

  __ check_and_handle_earlyret(Gtemp);

  __ dispatch_next(state, step);

  return entry;

}

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

  address entry = __ pc();

  __ get_constant_pool_cache(LcpoolCache); // load LcpoolCache

#if INCLUDE_JVMCI

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

  // only occur on method entry so emit it only for vtos with step 0.

  if (EnableJVMCI && state == vtos && step == 0) {

    Label L;

    Address pending_monitor_enter_addr(G2_thread, JavaThread::pending_monitorenter_offset());

    __ ldbool(pending_monitor_enter_addr, Gtemp);  // Load if pending monitor enter

    __ cmp_and_br_short(Gtemp, G0, Assembler::equal, Assembler::pn, L);

    // Clear flag.

    __ stbool(G0, pending_monitor_enter_addr);

    // Take lock.

    lock_method();

    __ bind(L);

  } else {

#ifdef ASSERT

    if (EnableJVMCI) {

      Label L;

      Address pending_monitor_enter_addr(G2_thread, JavaThread::pending_monitorenter_offset());

      __ ldbool(pending_monitor_enter_addr, Gtemp);  // Load if pending monitor enter

      __ cmp_and_br_short(Gtemp, G0, Assembler::equal, Assembler::pn, L);

      __ stop("unexpected pending monitor in deopt entry");

      __ bind(L);

    }

#endif

  }

#endif

  { Label L;

    Address exception_addr(G2_thread, Thread::pending_exception_offset());

    __ ld_ptr(exception_addr, Gtemp);  // Load pending exception.

    __ br_null_short(Gtemp, Assembler::pt, 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;

}

// A result handler converts/unboxes a native call result into

// a java interpreter/compiler result. The current frame is an

// interpreter frame. The activation frame unwind code must be

// consistent with that of TemplateTable::_return(...). In the

// case of native methods, the caller's SP was not modified.

address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {

  address entry = __ pc();

  Register Itos_i  = Otos_i ->after_save();

  Register Itos_l  = Otos_l ->after_save();

  Register Itos_l1 = Otos_l1->after_save();

  Register Itos_l2 = Otos_l2->after_save();

  switch (type) {

    case T_BOOLEAN: __ subcc(G0, O0, G0); __ addc(G0, 0, Itos_i); break; // !0 => true; 0 => false

    case T_CHAR   : __ sll(O0, 16, O0); __ srl(O0, 16, Itos_i);   break; // cannot use and3, 0xFFFF too big as immediate value!

    case T_BYTE   : __ sll(O0, 24, O0); __ sra(O0, 24, Itos_i);   break;

    case T_SHORT  : __ sll(O0, 16, O0); __ sra(O0, 16, Itos_i);   break;

    case T_LONG   :

    case T_INT    : __ mov(O0, Itos_i);                         break;

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

    case T_FLOAT  : assert(F0 == Ftos_f, "fix this code" );     break;

    case T_DOUBLE : assert(F0 == Ftos_d, "fix this code" );     break;

    case T_OBJECT :

      __ ld_ptr(FP, (frame::interpreter_frame_oop_temp_offset*wordSize) + STACK_BIAS, Itos_i);

      __ verify_oop(Itos_i);

      break;

    default       : ShouldNotReachHere();

  }

  __ ret();                           // return from interpreter activation

  __ delayed()->restore(I5_savedSP, G0, SP);  // remove interpreter frame

  NOT_PRODUCT(__ emit_int32(0);)       // marker for disassembly

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

//

// Lmethod: method

// ??: invocation counter

//

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

  // Note: In tiered we increment either counters in MethodCounters* or in

  // MDO depending if we're profiling or not.

  const Register G3_method_counters = G3_scratch;

  Label done;

  if (TieredCompilation) {

    const int increment = InvocationCounter::count_increment;

    Label no_mdo;

    if (ProfileInterpreter) {

      // If no method data exists, go to profile_continue.

      __ ld_ptr(Lmethod, Method::method_data_offset(), G4_scratch);

      __ br_null_short(G4_scratch, Assembler::pn, no_mdo);

      // Increment counter

      Address mdo_invocation_counter(G4_scratch,

                                     in_bytes(MethodData::invocation_counter_offset()) +

                                     in_bytes(InvocationCounter::counter_offset()));

      Address mask(G4_scratch, in_bytes(MethodData::invoke_mask_offset()));

      __ increment_mask_and_jump(mdo_invocation_counter, increment, mask,

                                 G3_scratch, Lscratch,

                                 Assembler::zero, overflow);

      __ ba_short(done);

    }

    // Increment counter in MethodCounters*

    __ bind(no_mdo);

    Address invocation_counter(G3_method_counters,

            in_bytes(MethodCounters::invocation_counter_offset()) +

            in_bytes(InvocationCounter::counter_offset()));

    __ get_method_counters(Lmethod, G3_method_counters, done);

    Address mask(G3_method_counters, in_bytes(MethodCounters::invoke_mask_offset()));

    __ increment_mask_and_jump(invocation_counter, increment, mask,

                               G4_scratch, Lscratch,

                               Assembler::zero, overflow);

    __ bind(done);

  } else { // not TieredCompilation

    // Update standard invocation counters

    __ get_method_counters(Lmethod, G3_method_counters, done);

    __ increment_invocation_counter(G3_method_counters, O0, G4_scratch);

    if (ProfileInterpreter) {

      Address interpreter_invocation_counter(G3_method_counters,

            in_bytes(MethodCounters::interpreter_invocation_counter_offset()));

      __ ld(interpreter_invocation_counter, G4_scratch);

      __ inc(G4_scratch);

      __ st(G4_scratch, interpreter_invocation_counter);

    }

    if (ProfileInterpreter && profile_method != NULL) {

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

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

      __ ld(profile_limit, G1_scratch);

      __ cmp_and_br_short(O0, G1_scratch, Assembler::lessUnsigned, Assembler::pn, *profile_method_continue);

      // if no method data exists, go to profile_method

      __ test_method_data_pointer(*profile_method);

    }

    Address invocation_limit(G3_method_counters, in_bytes(MethodCounters::interpreter_invocation_limit_offset()));

    __ ld(invocation_limit, G3_scratch);

    __ cmp(O0, G3_scratch);

    __ br(Assembler::greaterEqualUnsigned, false, Assembler::pn, *overflow); // Far distance

    __ delayed()->nop();

    __ bind(done);

  }

}

// Allocate monitor and lock method (asm interpreter)

// ebx - Method*

//

void TemplateInterpreterGenerator::lock_method() {

  __ ld(Lmethod, in_bytes(Method::access_flags_offset()), O0);  // Load access flags.

#ifdef ASSERT

 { Label ok;

   __ btst(JVM_ACC_SYNCHRONIZED, O0);

   __ br( Assembler::notZero, false, Assembler::pt, ok);

   __ delayed()->nop();

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

   __ bind(ok);

  }

#endif // ASSERT

  // get synchronization object to O0

  { Label done;

    __ btst(JVM_ACC_STATIC, O0);

    __ br( Assembler::zero, true, Assembler::pt, done);

    __ delayed()->ld_ptr(Llocals, Interpreter::local_offset_in_bytes(0), O0); // get receiver for not-static case