/*

 * 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 "interpreter/bytecodeHistogram.hpp"

#include "interpreter/cppInterpreter.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterGenerator.hpp"

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

#ifdef SHARK

#include "shark/shark_globals.hpp"

#endif

#ifdef CC_INTERP

// Routine exists to make tracebacks look decent in debugger

// while "shadow" interpreter frames are on stack. It is also

// used to distinguish interpreter frames.

extern "C" void RecursiveInterpreterActivation(interpreterState istate) {

  ShouldNotReachHere();

}

bool CppInterpreter::contains(address pc) {

  return ( _code->contains(pc) ||

         ( pc == (CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation) + frame::pc_return_offset)));

}

#define STATE(field_name) Lstate, in_bytes(byte_offset_of(BytecodeInterpreter, field_name))

#define __ _masm->

Label frame_manager_entry;

Label fast_accessor_slow_entry_path;  // fast accessor methods need to be able to jmp to unsynchronized

                                      // c++ interpreter entry point this holds that entry point label.

static address unctrap_frame_manager_entry  = NULL;

static address interpreter_return_address  = NULL;

static address deopt_frame_manager_return_atos  = NULL;

static address deopt_frame_manager_return_btos  = NULL;

static address deopt_frame_manager_return_itos  = NULL;

static address deopt_frame_manager_return_ltos  = NULL;

static address deopt_frame_manager_return_ftos  = NULL;

static address deopt_frame_manager_return_dtos  = NULL;

static address deopt_frame_manager_return_vtos  = NULL;

const Register prevState = G1_scratch;

void InterpreterGenerator::save_native_result(void) {

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

  __ stf(FloatRegisterImpl::D, F0, STATE(_native_fresult));

#ifdef _LP64

  __ stx(O0, STATE(_native_lresult));

#else

  __ std(O0, STATE(_native_lresult));

#endif

}

void InterpreterGenerator::restore_native_result(void) {

  // Restore any method result value

  __ ldf(FloatRegisterImpl::D, STATE(_native_fresult), F0);

#ifdef _LP64

  __ ldx(STATE(_native_lresult), O0);

#else

  __ ldd(STATE(_native_lresult), O0);

#endif

}

// 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 CppInterpreterGenerator::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(STATE(_oop_temp), 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;

}

// tosca based result to c++ interpreter stack based result.

// Result goes to address in L1_scratch

address CppInterpreterGenerator::generate_tosca_to_stack_converter(BasicType type) {

  // A result is in the native abi result register from a native method call.

  // We need to return this result to the interpreter by pushing the result on the interpreter's

  // stack. This is relatively simple the destination is in L1_scratch

  // i.e. L1_scratch is the first free element on the stack. If we "push" a return value we must

  // adjust L1_scratch

  address entry = __ pc();

  switch (type) {

    case T_BOOLEAN:

      // !0 => true; 0 => false

      __ subcc(G0, O0, G0);

      __ addc(G0, 0, O0);

      __ st(O0, L1_scratch, 0);

      __ sub(L1_scratch, wordSize, L1_scratch);

      break;

    // cannot use and3, 0xFFFF too big as immediate value!

    case T_CHAR   :

      __ sll(O0, 16, O0);

      __ srl(O0, 16, O0);

      __ st(O0, L1_scratch, 0);

      __ sub(L1_scratch, wordSize, L1_scratch);

      break;

    case T_BYTE   :

      __ sll(O0, 24, O0);

      __ sra(O0, 24, O0);

      __ st(O0, L1_scratch, 0);

      __ sub(L1_scratch, wordSize, L1_scratch);

      break;

    case T_SHORT  :

      __ sll(O0, 16, O0);

      __ sra(O0, 16, O0);

      __ st(O0, L1_scratch, 0);

      __ sub(L1_scratch, wordSize, L1_scratch);

      break;

    case T_LONG   :

#ifndef _LP64

#if 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.

      __ stx(G1, L1_scratch, -wordSize);

#else

      // native result is in O0, O1

      __ st(O1, L1_scratch, 0);                      // Low order

      __ st(O0, L1_scratch, -wordSize);              // High order

#endif /* COMPILER2 */

#else

      __ stx(O0, L1_scratch, -wordSize);

#endif

      __ sub(L1_scratch, 2*wordSize, L1_scratch);

      break;

    case T_INT    :

      __ st(O0, L1_scratch, 0);

      __ sub(L1_scratch, wordSize, L1_scratch);

      break;

    case T_VOID   : /* nothing to do */

      break;

    case T_FLOAT  :

      __ stf(FloatRegisterImpl::S, F0, L1_scratch, 0);

      __ sub(L1_scratch, wordSize, L1_scratch);

      break;

    case T_DOUBLE :

      // Every stack slot is aligned on 64 bit, However is this

      // the correct stack slot on 64bit?? QQQ

      __ stf(FloatRegisterImpl::D, F0, L1_scratch, -wordSize);

      __ sub(L1_scratch, 2*wordSize, L1_scratch);

      break;

    case T_OBJECT :

      __ verify_oop(O0);

      __ st_ptr(O0, L1_scratch, 0);

      __ sub(L1_scratch, wordSize, L1_scratch);

      break;

    default       : ShouldNotReachHere();

  }

  __ retl();                          // return from interpreter activation

  __ delayed()->nop();                // schedule this better

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

  return entry;

}

address CppInterpreterGenerator::generate_stack_to_stack_converter(BasicType type) {

  // A result is in the java expression stack of the interpreted method that has just

  // returned. Place this result on the java expression stack of the caller.

  //

  // The current interpreter activation in Lstate is for the method just returning its

  // result. So we know that the result of this method is on the top of the current

  // execution stack (which is pre-pushed) and will be return to the top of the caller

  // stack. The top of the callers stack is the bottom of the locals of the current

  // activation.

  // Because of the way activation are managed by the frame manager the value of esp is

  // below both the stack top of the current activation and naturally the stack top

  // of the calling activation. This enable this routine to leave the return address

  // to the frame manager on the stack and do a vanilla return.

  //

  // On entry: O0 - points to source (callee stack top)

  //           O1 - points to destination (caller stack top [i.e. free location])

  // destroys O2, O3

  //

  address entry = __ pc();

  switch (type) {

    case T_VOID:  break;

      break;

    case T_FLOAT  :

    case T_BOOLEAN:

    case T_CHAR   :

    case T_BYTE   :

    case T_SHORT  :

    case T_INT    :

      // 1 word result

      __ ld(O0, 0, O2);

      __ st(O2, O1, 0);

      __ sub(O1, wordSize, O1);

      break;

    case T_DOUBLE  :

    case T_LONG    :

      // return top two words on current expression stack to caller's expression stack

      // The caller's expression stack is adjacent to the current frame manager's intepretState

      // except we allocated one extra word for this intepretState so we won't overwrite it

      // when we return a two word result.

#ifdef _LP64

      __ ld_ptr(O0, 0, O2);

      __ st_ptr(O2, O1, -wordSize);

#else

      __ ld(O0, 0, O2);

      __ ld(O0, wordSize, O3);

      __ st(O3, O1, 0);

      __ st(O2, O1, -wordSize);

#endif

      __ sub(O1, 2*wordSize, O1);

      break;

    case T_OBJECT :

      __ ld_ptr(O0, 0, O2);

      __ verify_oop(O2);                                               // verify it

      __ st_ptr(O2, O1, 0);

      __ sub(O1, wordSize, O1);

      break;

    default       : ShouldNotReachHere();

  }

  __ retl();

  __ delayed()->nop(); // QQ schedule this better

  return entry;

}

address CppInterpreterGenerator::generate_stack_to_native_abi_converter(BasicType type) {

  // A result is in the java expression stack of the interpreted method that has just

  // returned. Place this result in the native abi that the caller expects.

  // We are in a new frame registers we set must be in caller (i.e. callstub) frame.

  //

  // Similar to generate_stack_to_stack_converter above. Called at a similar time from the

  // frame manager execept in this situation the caller is native code (c1/c2/call_stub)

  // and so rather than return result onto caller's java expression stack we return the

  // result in the expected location based on the native abi.

  // On entry: O0 - source (stack top)

  // On exit result in expected output register

  // QQQ schedule this better

  address entry = __ pc();

  switch (type) {

    case T_VOID:  break;

      break;

    case T_FLOAT  :

      __ ldf(FloatRegisterImpl::S, O0, 0, F0);

      break;

    case T_BOOLEAN:

    case T_CHAR   :

    case T_BYTE   :

    case T_SHORT  :

    case T_INT    :

      // 1 word result

      __ ld(O0, 0, O0->after_save());

      break;

    case T_DOUBLE  :

      __ ldf(FloatRegisterImpl::D, O0, 0, F0);

      break;

    case T_LONG    :

      // return top two words on current expression stack to caller's expression stack

      // The caller's expression stack is adjacent to the current frame manager's interpretState

      // except we allocated one extra word for this intepretState so we won't overwrite it

      // when we return a two word result.

#ifdef _LP64

      __ ld_ptr(O0, 0, O0->after_save());

#else

      __ ld(O0, wordSize, O1->after_save());

      __ ld(O0, 0, O0->after_save());

#endif

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

      // C2 expects long results in G1 we can't tell if we're returning to interpreted

      // or compiled so just be safe use G1 and O0/O1

      // Shift bits into high (msb) of G1

      __ sllx(Otos_l1->after_save(), 32, G1);

      // Zero extend low bits

      __ srl (Otos_l2->after_save(), 0, Otos_l2->after_save());

      __ or3 (Otos_l2->after_save(), G1, G1);

#endif /* COMPILER2 */

      break;

    case T_OBJECT :

      __ ld_ptr(O0, 0, O0->after_save());

      __ verify_oop(O0->after_save());                                               // verify it

      break;

    default       : ShouldNotReachHere();

  }

  __ retl();

  __ delayed()->nop();

  return entry;

}

address CppInterpreter::return_entry(TosState state, int length) {

  // make it look good in the debugger

  return CAST_FROM_FN_PTR(address, RecursiveInterpreterActivation) + frame::pc_return_offset;

}

address CppInterpreter::deopt_entry(TosState state, int length) {

  address ret = NULL;

  if (length != 0) {

    switch (state) {

      case atos: ret = deopt_frame_manager_return_atos; break;

      case btos: ret = deopt_frame_manager_return_btos; break;

      case ctos:

      case stos:

      case itos: ret = deopt_frame_manager_return_itos; break;

      case ltos: ret = deopt_frame_manager_return_ltos; break;

      case ftos: ret = deopt_frame_manager_return_ftos; break;

      case dtos: ret = deopt_frame_manager_return_dtos; break;

      case vtos: ret = deopt_frame_manager_return_vtos; break;

    }

  } else {

    ret = unctrap_frame_manager_entry;  // re-execute the bytecode ( e.g. uncommon trap)

  }

  assert(ret != NULL, "Not initialized");

  return ret;

}

//

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

  // Update standard invocation counters

  }

  Address invocation_limit(G3_scratch, (address)&InvocationCounter::InterpreterInvocationLimit);

  __ sethi(invocation_limit);

  __ ld(invocation_limit, G3_scratch);

  __ cmp(O0, G3_scratch);

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

  __ delayed()->nop();

}

address InterpreterGenerator::generate_empty_entry(void) {

  // A method that does nothing but return...

  address entry = __ pc();

  Label slow_path;

  // do nothing for empty methods (do not even increment invocation counter)

  if ( UseFastEmptyMethods) {

    // If we need a safepoint check, generate full interpreter entry.

    Address sync_state(G3_scratch, SafepointSynchronize::address_of_state());

    __ load_contents(sync_state, G3_scratch);

    __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized);

    __ br(Assembler::notEqual, false, Assembler::pn, frame_manager_entry);

    __ delayed()->nop();

    // Code: _return

    __ retl();

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

    return entry;

  }

  return NULL;

}

// Call an accessor method (assuming it is resolved, otherwise drop into

// vanilla (slow path) entry

// Generates code to elide accessor methods

// Uses G3_scratch and G1_scratch as scratch

address InterpreterGenerator::generate_accessor_entry(void) {

  // Code: _aload_0, _(i|a)getfield, _(i|a)return or any rewrites thereof;

  // parameter size = 1

  // Note: We can only use this code if the getfield has been resolved

  //       and if we don't have a null-pointer exception => check for

  //       these conditions first and use slow path if necessary.

  address entry = __ pc();

  Label slow_path;

  if ( UseFastAccessorMethods) {

    // Check if we need to reach a safepoint and generate full interpreter

    // frame if so.

    Address sync_state(G3_scratch, SafepointSynchronize::address_of_state());

    __ load_contents(sync_state, G3_scratch);

    __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized);

    __ br(Assembler::notEqual, false, Assembler::pn, slow_path);

    __ delayed()->nop();

    // Check if local 0 != NULL

    __ ld_ptr(Gargs, G0, Otos_i ); // get local 0

    __ tst(Otos_i);  // check if local 0 == NULL and go the slow path

    __ brx(Assembler::zero, false, Assembler::pn, slow_path);

    __ delayed()->nop();

    // read first instruction word and extract bytecode @ 1 and index @ 2

    // get first 4 bytes of the bytecodes (big endian!)

    __ ld_ptr(Address(G5_method, 0, in_bytes(Method::const_offset())), G1_scratch);

    __ ld(Address(G1_scratch, 0, in_bytes(ConstMethod::codes_offset())), G1_scratch);

    // move index @ 2 far left then to the right most two bytes.

    __ sll(G1_scratch, 2*BitsPerByte, G1_scratch);

    __ srl(G1_scratch, 2*BitsPerByte - exact_log2(in_words(

                      ConstantPoolCacheEntry::size()) * BytesPerWord), G1_scratch);

    // get constant pool cache

    __ ld_ptr(G5_method, in_bytes(Method::const_offset()), G3_scratch);

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

    __ ld_ptr(G3_scratch, ConstantPool::cache_offset_in_bytes(), G3_scratch);

    // get specific constant pool cache entry

    __ add(G3_scratch, G1_scratch, G3_scratch);

    // Check the constant Pool cache entry to see if it has been resolved.

    // If not, need the slow path.

    ByteSize cp_base_offset = ConstantPoolCache::base_offset();

    __ ld_ptr(G3_scratch, in_bytes(cp_base_offset + ConstantPoolCacheEntry::indices_offset()), G1_scratch);

    __ srl(G1_scratch, 2*BitsPerByte, G1_scratch);

    __ and3(G1_scratch, 0xFF, G1_scratch);

    __ cmp(G1_scratch, Bytecodes::_getfield);

    __ br(Assembler::notEqual, false, Assembler::pn, slow_path);

    __ delayed()->nop();

    // Get the type and return field offset from the constant pool cache

    __ ld_ptr(G3_scratch, in_bytes(cp_base_offset + ConstantPoolCacheEntry::flags_offset()), G1_scratch);

    __ ld_ptr(G3_scratch, in_bytes(cp_base_offset + ConstantPoolCacheEntry::f2_offset()), G3_scratch);

    Label xreturn_path;

    // Need to differentiate between igetfield, agetfield, bgetfield etc.

    // because they are different sizes.

    // Get the type from the constant pool cache