/*

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

#include "interpreter/bytecodeHistogram.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterGenerator.hpp"

#include "interpreter/interpreterRuntime.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/debug.hpp"

#include "utilities/macros.hpp"

#ifndef CC_INTERP

#ifndef FAST_DISPATCH

#define FAST_DISPATCH 1

#endif

#undef FAST_DISPATCH

// Generation of Interpreter

//

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

#define __ _masm->

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

void InterpreterGenerator::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);

#ifdef _LP64

  __ stx(O0, l_tmp);

#else

  __ std(O0, l_tmp);

#endif

}

void InterpreterGenerator::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);

#ifdef _LP64

  __ ldx(l_tmp, O0);

#else

  __ ldd(l_tmp, O0);

#endif

}

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(const char* name) {

  address entry = __ pc();

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

  __ empty_expression_stack();

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

  // index to G4_scratch for the VM call

  __ mov(G3_scratch, G4_scratch);

  __ set((intptr_t)name, G3_scratch);

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

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

  }

#if !defined(_LP64) && defined(COMPILER2)

  // All return values are where we want them, except for Longs.  C2 returns

  // longs in G1 in the 32-bit build whereas the interpreter wants them in O0/O1.

  // Since the interpreter will return longs in G1 and O0/O1 in the 32bit

  // build even if we are returning from interpreted we just do a little

  // stupid shuffing.

  // Note: I tried to make c2 return longs in O0/O1 and G1 so we wouldn't have to

  // do this here. Unfortunately if we did a rethrow we'd see an machepilog node

  // first which would move g1 -> O0/O1 and destroy the exception we were throwing.

  if (state == ltos) {

    __ srl (G1,  0, O1);

    __ srlx(G1, 32, O0);

  }

#endif // !_LP64 && COMPILER2

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

  __ dispatch_next(state, step);

  return entry;

}

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

  address entry = __ pc();

  __ get_constant_pool_cache(LcpoolCache); // load LcpoolCache

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

  }

  __ dispatch_next(state, step);

  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   :

#ifndef _LP64

                    __ mov(O1, Itos_l2);  // move other half of long

#endif              // ifdef or no ifdef, fall through to the T_INT case

    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;

}

address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {

  address entry = __ pc();

  __ dispatch_next(state);

  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 InterpreterGenerator::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 Rcounters = G3_scratch;

  Label done;

  if (TieredCompilation) {

    const int increment = InvocationCounter::count_increment;

    const int mask = ((1 << Tier0InvokeNotifyFreqLog) - 1) << InvocationCounter::count_shift;

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

      __ 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(Rcounters,

            in_bytes(MethodCounters::invocation_counter_offset()) +

            in_bytes(InvocationCounter::counter_offset()));

    __ get_method_counters(Lmethod, Rcounters, done);

    __ increment_mask_and_jump(invocation_counter, increment, mask,

                               G4_scratch, Lscratch,

                               Assembler::zero, overflow);

    __ bind(done);

  } else {

    // Update standard invocation counters

    __ get_method_counters(Lmethod, Rcounters, done);

    __ increment_invocation_counter(Rcounters, O0, G4_scratch);

    if (ProfileInterpreter) {

      Address interpreter_invocation_counter(Rcounters,

            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

      AddressLiteral profile_limit((address)&InvocationCounter::InterpreterProfileLimit);

      __ load_contents(profile_limit, G3_scratch);

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

      // if no method data exists, go to profile_method

      __ test_method_data_pointer(*profile_method);

    }

    AddressLiteral invocation_limit((address)&InvocationCounter::InterpreterInvocationLimit);

    __ load_contents(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 InterpreterGenerator::lock_method(void) {

  __ 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;

    const int mirror_offset = in_bytes(Klass::java_mirror_offset());

    __ 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

    __ ld_ptr( Lmethod, in_bytes(Method::const_offset()), O0);

    __ ld_ptr( O0, in_bytes(ConstMethod::constants_offset()), O0);

    __ ld_ptr( O0, ConstantPool::pool_holder_offset_in_bytes(), O0);

    // lock the mirror, not the Klass*

    __ ld_ptr( O0, mirror_offset, O0);

#ifdef ASSERT

    __ tst(O0);

    __ breakpoint_trap(Assembler::zero, Assembler::ptr_cc);

#endif // ASSERT

    __ bind(done);

  }

  __ add_monitor_to_stack(true, noreg, noreg);  // allocate monitor elem

  __ st_ptr( O0, Lmonitors, BasicObjectLock::obj_offset_in_bytes());   // store object

  // __ untested("lock_object from method entry");

  __ lock_object(Lmonitors, O0);

}

void TemplateInterpreterGenerator::generate_stack_overflow_check(Register Rframe_size,

                                                         Register Rscratch,

                                                         Register Rscratch2) {

  const int page_size = os::vm_page_size();

  Label after_frame_check;

  assert_different_registers(Rframe_size, Rscratch, Rscratch2);

  __ set(page_size, Rscratch);

  __ cmp_and_br_short(Rframe_size, Rscratch, Assembler::lessEqual, Assembler::pt, after_frame_check);

  // get the stack base, and in debug, verify it is non-zero

  __ ld_ptr( G2_thread, Thread::stack_base_offset(), Rscratch );

#ifdef ASSERT

  Label base_not_zero;

  __ br_notnull_short(Rscratch, Assembler::pn, base_not_zero);

  __ stop("stack base is zero in generate_stack_overflow_check");

  __ bind(base_not_zero);

#endif

  // get the stack size, and in debug, verify it is non-zero

  assert( sizeof(size_t) == sizeof(intptr_t), "wrong load size" );

  __ ld_ptr( G2_thread, Thread::stack_size_offset(), Rscratch2 );

#ifdef ASSERT

  Label size_not_zero;

  __ br_notnull_short(Rscratch2, Assembler::pn, size_not_zero);

  __ stop("stack size is zero in generate_stack_overflow_check");

  __ bind(size_not_zero);

#endif

  // compute the beginning of the protected zone minus the requested frame size

  __ sub( Rscratch, Rscratch2,   Rscratch );

  __ set( (StackRedPages+StackYellowPages) * page_size, Rscratch2 );

  __ add( Rscratch, Rscratch2,   Rscratch );

  // Add in the size of the frame (which is the same as subtracting it from the

  // SP, which would take another register

  __ add( Rscratch, Rframe_size, Rscratch );

  // the frame is greater than one page in size, so check against

  // the bottom of the stack

  __ cmp_and_brx_short(SP, Rscratch, Assembler::greaterUnsigned, Assembler::pt, after_frame_check);

  // the stack will overflow, throw an exception

  // Note that SP is restored to sender's sp (in the delay slot). This

  // is necessary if the sender's frame is an extended compiled frame

  // (see gen_c2i_adapter()) and safer anyway in case of JSR292

  // adaptations.

  // Note also that 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");

  AddressLiteral stub(StubRoutines::throw_StackOverflowError_entry());

  __ jump_to(stub, Rscratch);

  __ delayed()->mov(O5_savedSP, SP);

  // if you get to here, then there is enough stack space

  __ bind( after_frame_check );

}

//

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

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

void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {

  //

  //

  // The entry code sets up a new interpreter frame in 4 steps:

  //

  // 1) Increase caller's SP by for the extra local space needed:

  //    (check for overflow)

  //    Efficient implementation of xload/xstore bytecodes requires

  //    that arguments and non-argument locals are in a contigously

  //    addressable memory block => non-argument locals must be

  //    allocated in the caller's frame.

  //

  // 2) Create a new stack frame and register window:

  //    The new stack frame must provide space for the standard

  //    register save area, the maximum java expression stack size,

  //    the monitor slots (0 slots initially), and some frame local

  //    scratch locations.

  //

  // 3) The following interpreter activation registers must be setup:

  //    Lesp       : expression stack pointer

  //    Lbcp       : bytecode pointer

  //    Lmethod    : method

  //    Llocals    : locals pointer

  //    Lmonitors  : monitor pointer

  //    LcpoolCache: constant pool cache

  //

  // 4) Initialize the non-argument locals if necessary:

  //    Non-argument locals may need to be initialized to NULL

  //    for GC to work. If the oop-map information is accurate

  //    (in the absence of the JSR problem), no initialization

  //    is necessary.

  //

  // (gri - 2/25/2000)

  int rounded_vm_local_words = round_to( frame::interpreter_frame_vm_local_words, WordsPerLong );

  const int extra_space =

    rounded_vm_local_words +                   // frame local scratch space

    Method::extra_stack_entries() +            // extra stack for jsr 292

    frame::memory_parameter_word_sp_offset +   // register save area

    (native_call ? frame::interpreter_frame_extra_outgoing_argument_words : 0);

  const Register Glocals_size = G3;

  const Register RconstMethod = Glocals_size;

  const Register Otmp1 = O3;

  const Register Otmp2 = O4;

  // Lscratch can't be used as a temporary because the call_stub uses

  // it to assert that the stack frame was setup correctly.

  const Address constMethod       (G5_method, Method::const_offset());

  const Address size_of_parameters(RconstMethod, ConstMethod::size_of_parameters_offset());

  __ ld_ptr( constMethod, RconstMethod );

  __ lduh( size_of_parameters, Glocals_size);

  // Gargs points to first local + BytesPerWord