/*

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

 * Copyright 2012, 2013 SAP AG. 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/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"

#ifdef SHARK

#include "shark/shark_globals.hpp"

#endif

#ifdef CC_INTERP

#define __ _masm->

// Contains is used for identifying interpreter frames during a stack-walk.

// A frame with a PC in InterpretMethod must be identified as a normal C frame.

bool CppInterpreter::contains(address pc) {

  return _code->contains(pc);

}

#ifdef PRODUCT

#define BLOCK_COMMENT(str) // nothing

#else

#define BLOCK_COMMENT(str) __ block_comment(str)

#endif

#define BIND(label) bind(label); BLOCK_COMMENT(#label ":")

static address interpreter_frame_manager        = NULL;

static address frame_manager_specialized_return = NULL;

static address native_entry                     = NULL;

static address interpreter_return_address       = NULL;

static address unctrap_frame_manager_entry      = 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;

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

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

// interpreter frame.

address CppInterpreterGenerator::generate_result_handler_for(BasicType type) {

  return AbstractInterpreterGenerator::generate_result_handler_for(type);

}

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

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.

  //

  // Registers alive:

  //   R3_ARG1(R3_RET)/F1_ARG1(F1_RET) - result to move

  //   R4_ARG2                         - address of tos

  //   LR

  //

  // Registers updated:

  //   R3_RET(R3_ARG1)   - address of new tos (== R17_tos for T_VOID)

  //

  int number_of_used_slots = 1;

  const Register tos = R4_ARG2;

  Label done;

  Label is_false;

  address entry = __ pc();

  switch (type) {

  case T_BOOLEAN:

    __ cmpwi(CCR0, R3_RET, 0);

    __ beq(CCR0, is_false);

    __ li(R3_RET, 1);

    __ stw(R3_RET, 0, tos);

    __ b(done);

    __ bind(is_false);

    __ li(R3_RET, 0);

    __ stw(R3_RET, 0, tos);

    break;

  case T_BYTE:

  case T_CHAR:

  case T_SHORT:

  case T_INT:

    __ stw(R3_RET, 0, tos);

    break;

  case T_LONG:

    number_of_used_slots = 2;

    // mark unused slot for debugging

    // long goes to topmost slot

    __ std(R3_RET, -BytesPerWord, tos);

    __ li(R3_RET, 0);

    __ std(R3_RET, 0, tos);

    break;

  case T_OBJECT:

    __ verify_oop(R3_RET);

    __ std(R3_RET, 0, tos);

    break;

  case T_FLOAT:

    __ stfs(F1_RET, 0, tos);

    break;

  case T_DOUBLE:

    number_of_used_slots = 2;

    // mark unused slot for debugging

    __ li(R3_RET, 0);

    __ std(R3_RET, 0, tos);

    // double goes to topmost slot

    __ stfd(F1_RET, -BytesPerWord, tos);

    break;

  case T_VOID:

    number_of_used_slots = 0;

    break;

  default:

    ShouldNotReachHere();

  }

  __ BIND(done);

  // new expression stack top

  __ addi(R3_RET, tos, -BytesPerWord * number_of_used_slots);

  __ blr();

  return entry;

}

address CppInterpreterGenerator::generate_stack_to_stack_converter(BasicType type) {

  //

  // Copy the result from the callee's stack to the caller's stack,

  // caller and callee both being interpreted.

  //

  // Registers alive

  //   R3_ARG1        - address of callee's tos + BytesPerWord

  //   R4_ARG2        - address of caller's tos [i.e. free location]

  //   LR

  //

  //   stack grows upwards, memory grows downwards.

  //

  //   [      free         ]  <-- callee's tos

  //   [  optional result  ]  <-- R3_ARG1

  //   [  optional dummy   ]

  //          ...

  //   [      free         ]  <-- caller's tos, R4_ARG2

  //          ...

  // Registers updated

  //   R3_RET(R3_ARG1) - address of caller's new tos

  //

  //   stack grows upwards, memory grows downwards.

  //

  //   [      free         ]  <-- current tos, R3_RET

  //   [  optional result  ]

  //   [  optional dummy   ]

  //          ...

  //

  const Register from = R3_ARG1;

  const Register ret  = R3_ARG1;

  const Register tos  = R4_ARG2;

  const Register tmp1 = R21_tmp1;

  const Register tmp2 = R22_tmp2;

  address entry = __ pc();

  switch (type) {

  case T_BOOLEAN:

  case T_BYTE:

  case T_CHAR:

  case T_SHORT:

  case T_INT:

  case T_FLOAT:

    __ lwz(tmp1, 0, from);

    __ stw(tmp1, 0, tos);

    // New expression stack top.

    __ addi(ret, tos, - BytesPerWord);

    break;

  case T_LONG:

  case T_DOUBLE:

    // Move both entries for debug purposes even though only one is live.

    __ ld(tmp1, BytesPerWord, from);

    __ ld(tmp2, 0, from);

    __ std(tmp1, 0, tos);

    __ std(tmp2, -BytesPerWord, tos);

    // New expression stack top.

    __ addi(ret, tos, - 2 * BytesPerWord); // two slots

    break;

  case T_OBJECT:

    __ ld(tmp1, 0, from);

    __ verify_oop(tmp1);

    __ std(tmp1, 0, tos);

    // New expression stack top.

    __ addi(ret, tos, - BytesPerWord);

    break;

  case T_VOID:

    // New expression stack top.

    __ mr(ret, tos);

    break;

  default:

    ShouldNotReachHere();

  }

  __ blr();

  return entry;

}

address CppInterpreterGenerator::generate_stack_to_native_abi_converter(BasicType type) {

  //

  // Load a result from the callee's stack into the caller's expecting

  // return register, callee being interpreted, caller being call stub

  // or jit code.

  //

  // Registers alive

  //   R3_ARG1   - callee expression tos + BytesPerWord

  //   LR

  //

  //   stack grows upwards, memory grows downwards.

  //

  //   [      free         ]  <-- callee's tos

  //   [  optional result  ]  <-- R3_ARG1

  //   [  optional dummy   ]

  //          ...

  //

  // Registers updated

  //   R3_RET(R3_ARG1)/F1_RET - result

  //

  const Register from = R3_ARG1;

  const Register ret = R3_ARG1;

  const FloatRegister fret = F1_ARG1;

  address entry = __ pc();

  // Implemented uniformly for both kinds of endianness. The interpreter

  // implements boolean, byte, char, and short as jint (4 bytes).

  switch (type) {

  case T_BOOLEAN:

  case T_CHAR:

    // zero extension

    __ lwz(ret, 0, from);

    break;

  case T_BYTE:

  case T_SHORT:

  case T_INT:

    // sign extension

    __ lwa(ret, 0, from);

    break;

  case T_LONG:

    __ ld(ret, 0, from);

    break;

  case T_OBJECT:

    __ ld(ret, 0, from);

    __ verify_oop(ret);

    break;

  case T_FLOAT:

    __ lfs(fret, 0, from);

    break;

  case T_DOUBLE:

    __ lfd(fret, 0, from);

    break;

  case T_VOID:

    break;

  default:

    ShouldNotReachHere();

  }

  __ blr();

  return entry;

}

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

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

  return interpreter_return_address;

}

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

      default: ShouldNotReachHere();

    }

  } else {

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

  }

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

  return ret;

}

//

// Helpers for commoning out cases in the various type of method entries.

//

//

// Registers alive

//   R16_thread      - JavaThread*

//   R1_SP           - old stack pointer

//   R19_method      - callee's Method

//   R17_tos         - address of caller's tos (prepushed)

//   R15_prev_state  - address of caller's BytecodeInterpreter or 0

//   return_pc in R21_tmp15 (only when called within generate_native_entry)

//

// Registers updated

//   R14_state       - address of callee's interpreter state

//   R1_SP           - new stack pointer

//   CCR4_is_synced  - current method is synchronized

//

void CppInterpreterGenerator::generate_compute_interpreter_state(Label& stack_overflow_return) {

  //

  // Stack layout at this point:

  //

  //   F1      [TOP_IJAVA_FRAME_ABI]              <-- R1_SP

  //           alignment (optional)

  //           [F1's outgoing Java arguments]     <-- R17_tos

  //           ...

  //   F2      [PARENT_IJAVA_FRAME_ABI]

  //            ...

  //=============================================================================

  // Allocate space for locals other than the parameters, the

  // interpreter state, monitors, and the expression stack.

  const Register local_count        = R21_tmp1;

  const Register parameter_count    = R22_tmp2;

  const Register max_stack          = R23_tmp3;

  // Must not be overwritten within this method!

  // const Register return_pc         = R29_tmp9;

  const ConditionRegister is_synced = CCR4_is_synced;

  const ConditionRegister is_native = CCR6;

  const ConditionRegister is_static = CCR7;

  assert(is_synced != is_native, "condition code registers must be distinct");

  assert(is_synced != is_static, "condition code registers must be distinct");

  assert(is_native != is_static, "condition code registers must be distinct");

  {

  // Local registers

  const Register top_frame_size     = R24_tmp4;

  const Register access_flags       = R25_tmp5;

  const Register state_offset       = R26_tmp6;

  Register mem_stack_limit          = R27_tmp7;

  const Register page_size          = R28_tmp8;

  BLOCK_COMMENT("compute_interpreter_state {");

  // access_flags = method->access_flags();

  // TODO: PPC port: assert(4 == methodOopDesc::sz_access_flags(), "unexpected field size");

  __ lwa(access_flags, method_(access_flags));

  // parameter_count = method->constMethod->size_of_parameters();

  // TODO: PPC port: assert(2 == ConstMethod::sz_size_of_parameters(), "unexpected field size");

  __ ld(max_stack, in_bytes(Method::const_offset()), R19_method);   // Max_stack holds constMethod for a while.

  __ lhz(parameter_count, in_bytes(ConstMethod::size_of_parameters_offset()), max_stack);

  // local_count = method->constMethod()->max_locals();

  // TODO: PPC port: assert(2 == ConstMethod::sz_max_locals(), "unexpected field size");

  __ lhz(local_count, in_bytes(ConstMethod::size_of_locals_offset()), max_stack);

  // max_stack = method->constMethod()->max_stack();

  // TODO: PPC port: assert(2 == ConstMethod::sz_max_stack(), "unexpected field size");

  __ lhz(max_stack, in_bytes(ConstMethod::max_stack_offset()), max_stack);

  if (EnableInvokeDynamic) {

    // Take into account 'extra_stack_entries' needed by method handles (see method.hpp).

    __ addi(max_stack, max_stack, Method::extra_stack_entries());

  }

  // mem_stack_limit = thread->stack_limit();

  __ ld(mem_stack_limit, thread_(stack_overflow_limit));

  // Point locals at the first argument. Method's locals are the

  // parameters on top of caller's expression stack.

  // tos points past last Java argument

  __ sldi(R18_locals, parameter_count, Interpreter::logStackElementSize);

  __ add(R18_locals, R17_tos, R18_locals);

  // R18_locals - i*BytesPerWord points to i-th Java local (i starts at 0)

  // Set is_native, is_synced, is_static - will be used later.

  __ testbitdi(is_native, R0, access_flags, JVM_ACC_NATIVE_BIT);

  __ testbitdi(is_synced, R0, access_flags, JVM_ACC_SYNCHRONIZED_BIT);

  assert(is_synced->is_nonvolatile(), "is_synced must be non-volatile");

  __ testbitdi(is_static, R0, access_flags, JVM_ACC_STATIC_BIT);

  // PARENT_IJAVA_FRAME_ABI

  //

  // frame_size =

  //   round_to((local_count - parameter_count)*BytesPerWord +

  //              2*BytesPerWord +

  //              alignment +

  //              frame::interpreter_frame_cinterpreterstate_size_in_bytes()

  //              sizeof(PARENT_IJAVA_FRAME_ABI)

  //              method->is_synchronized() ? sizeof(BasicObjectLock) : 0 +

  //              max_stack*BytesPerWord,

  //            16)

  //

  // Note that this calculation is exactly mirrored by

  // AbstractInterpreter::layout_activation_impl() [ and

  // AbstractInterpreter::size_activation() ]. Which is used by

  // deoptimization so that it can allocate the proper sized

  // frame. This only happens for interpreted frames so the extra

  // notes below about max_stack below are not important. The other

  // thing to note is that for interpreter frames other than the

  // current activation the size of the stack is the size of the live

  // portion of the stack at the particular bcp and NOT the maximum

  // stack that the method might use.

  //

  // If we're calling a native method, we replace max_stack (which is

  // zero) with space for the worst-case signature handler varargs

  // vector, which is:

  //

  //   max_stack = max(Argument::n_register_parameters, parameter_count+2);

  //

  // We add two slots to the parameter_count, one for the jni

  // environment and one for a possible native mirror.  We allocate

  // space for at least the number of ABI registers, even though

  // InterpreterRuntime::slow_signature_handler won't write more than

  // parameter_count+2 words when it creates the varargs vector at the

  // top of the stack.  The generated slow signature handler will just

  // load trash into registers beyond the necessary number.  We're

  // still going to cut the stack back by the ABI register parameter

  // count so as to get SP+16 pointing at the ABI outgoing parameter

  // area, so we need to allocate at least that much even though we're

  // going to throw it away.

  //

  // Adjust max_stack for native methods:

  Label skip_native_calculate_max_stack;

  __ bfalse(is_native, skip_native_calculate_max_stack);

  // if (is_native) {

  //  max_stack = max(Argument::n_register_parameters, parameter_count+2);

  __ addi(max_stack, parameter_count, 2*Interpreter::stackElementWords);

  __ cmpwi(CCR0, max_stack, Argument::n_register_parameters);

  __ bge(CCR0, skip_native_calculate_max_stack);

  __ li(max_stack,  Argument::n_register_parameters);

  // }

  __ bind(skip_native_calculate_max_stack);

  // max_stack is now in bytes

  __ slwi(max_stack, max_stack, Interpreter::logStackElementSize);

  // Calculate number of non-parameter locals (in slots):

  Label not_java;

  __ btrue(is_native, not_java);

  // if (!is_native) {

  //   local_count = non-parameter local count

  __ sub(local_count, local_count, parameter_count);

  // } else {

  //   // nothing to do: method->max_locals() == 0 for native methods

  // }

  __ bind(not_java);

  // Calculate top_frame_size and parent_frame_resize.

  {

  const Register parent_frame_resize = R12_scratch2;

  BLOCK_COMMENT("Compute top_frame_size.");

  // top_frame_size = TOP_IJAVA_FRAME_ABI

  //                  + size of interpreter state

  __ li(top_frame_size, frame::top_ijava_frame_abi_size

                        + frame::interpreter_frame_cinterpreterstate_size_in_bytes());

  //                  + max_stack

  __ add(top_frame_size, top_frame_size, max_stack);

  //                  + stack slots for a BasicObjectLock for synchronized methods

  {

    Label not_synced;

    __ bfalse(is_synced, not_synced);

    __ addi(top_frame_size, top_frame_size, frame::interpreter_frame_monitor_size_in_bytes());

    __ bind(not_synced);