/*

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

 * Copyright 2013, 2015 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"

#ifndef CC_INTERP

#include "asm/macroAssembler.inline.hpp"

#include "interpreter/bytecodeHistogram.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterGenerator.hpp"

#include "interpreter/interpreterRuntime.hpp"

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

#undef __

#define __ _masm->

#ifdef PRODUCT

#define BLOCK_COMMENT(str) /* nothing */

#else

#define BLOCK_COMMENT(str) __ block_comment(str)

#endif

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

// Actually we should never reach here since we do stack overflow checks before pushing any frame.

address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

  address entry = __ pc();

  __ unimplemented("generate_StackOverflowError_handler");

  return entry;

}

address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler(const char* name) {

  address entry = __ pc();

  __ empty_expression_stack();

  __ load_const_optimized(R4_ARG2, (address) name);

  // Index is in R17_tos.

  __ mr(R5_ARG3, R17_tos);

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

  return entry;

}

#if 0

// Call special ClassCastException constructor taking object to cast

// and target class as arguments.

address TemplateInterpreterGenerator::generate_ClassCastException_verbose_handler() {

  address entry = __ pc();

  // Expression stack must be empty before entering the VM if an

  // exception happened.

  __ empty_expression_stack();

  // Thread will be loaded to R3_ARG1.

  // Target class oop is in register R5_ARG3 by convention!

  __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ClassCastException_verbose), R17_tos, R5_ARG3);

  // Above call must not return here since exception pending.

  DEBUG_ONLY(__ should_not_reach_here();)

  return entry;

}

#endif

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.

  // Thread will be loaded to R3_ARG1.

  __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ClassCastException), R17_tos);

#ifdef ASSERT

  // Above call must not return here since exception pending.

  __ should_not_reach_here();

#endif

  return entry;

}

address TemplateInterpreterGenerator::generate_exception_handler_common(const char* name, const char* message, bool pass_oop) {

  address entry = __ pc();

  //__ untested("generate_exception_handler_common");

  Register Rexception = R17_tos;

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

  __ empty_expression_stack();

  __ load_const_optimized(R4_ARG2, (address) name, R11_scratch1);

  if (pass_oop) {

    __ mr(R5_ARG3, Rexception);

    __ call_VM(Rexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), false);

  } else {

    __ load_const_optimized(R5_ARG3, (address) message, R11_scratch1);

    __ call_VM(Rexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), false);

  }

  // Throw exception.

  __ mr(R3_ARG1, Rexception);

  __ load_const_optimized(R11_scratch1, Interpreter::throw_exception_entry(), R12_scratch2);

  __ mtctr(R11_scratch1);

  __ bctr();

  return entry;

}

address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {

  address entry = __ pc();

  __ unimplemented("generate_continuation_for");

  return entry;

}

// This entry is returned to when a call returns to the interpreter.

// When we arrive here, we expect that the callee stack frame is already popped.

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

  address entry = __ pc();

  // Move the value out of the return register back to the TOS cache of current frame.

  switch (state) {

    case ltos:

    case btos:

    case ctos:

    case stos:

    case atos:

    case itos: __ mr(R17_tos, R3_RET); break;   // RET -> TOS cache

    case ftos:

    case dtos: __ fmr(F15_ftos, F1_RET); break; // TOS cache -> GR_FRET

    case vtos: break;                           // Nothing to do, this was a void return.

    default  : ShouldNotReachHere();

  }

  __ restore_interpreter_state(R11_scratch1); // Sets R11_scratch1 = fp.

  __ ld(R12_scratch2, _ijava_state_neg(top_frame_sp), R11_scratch1);

  __ resize_frame_absolute(R12_scratch2, R11_scratch1, R0);

  // Compiled code destroys templateTableBase, reload.

  __ load_const_optimized(R25_templateTableBase, (address)Interpreter::dispatch_table((TosState)0), R12_scratch2);

  if (state == atos) {

    __ profile_return_type(R3_RET, R11_scratch1, R12_scratch2);

  }

  const Register cache = R11_scratch1;

  const Register size  = R12_scratch2;

  __ get_cache_and_index_at_bcp(cache, 1, index_size);

  // Get least significant byte of 64 bit value:

#if defined(VM_LITTLE_ENDIAN)

  __ lbz(size, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()), cache);

#else

  __ lbz(size, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()) + 7, cache);

#endif

  __ sldi(size, size, Interpreter::logStackElementSize);

  __ add(R15_esp, R15_esp, size);

  __ dispatch_next(state, step);

  return entry;

}

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

  address entry = __ pc();

  // If state != vtos, we're returning from a native method, which put it's result

  // into the result register. So move the value out of the return register back

  // to the TOS cache of current frame.

  switch (state) {

    case ltos:

    case btos:

    case ctos:

    case stos:

    case atos:

    case itos: __ mr(R17_tos, R3_RET); break;   // GR_RET -> TOS cache

    case ftos:

    case dtos: __ fmr(F15_ftos, F1_RET); break; // TOS cache -> GR_FRET

    case vtos: break;                           // Nothing to do, this was a void return.

    default  : ShouldNotReachHere();

  }

  // Load LcpoolCache @@@ should be already set!

  __ get_constant_pool_cache(R27_constPoolCache);

  // Handle a pending exception, fall through if none.

  __ check_and_forward_exception(R11_scratch1, R12_scratch2);

  // Start executing bytecodes.

  __ dispatch_next(state, step);

  return entry;

}

// A result handler converts the native result into java format.

// Use the shared code between c++ and template interpreter.

address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {

  return AbstractInterpreterGenerator::generate_result_handler_for(type);

}

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

//

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

  // Note: In tiered we increment either counters in method or in MDO depending if we're profiling or not.

  Register Rscratch1   = R11_scratch1;

  Register Rscratch2   = R12_scratch2;

  Register R3_counters = R3_ARG1;

  Label done;

  if (TieredCompilation) {

    const int increment = InvocationCounter::count_increment;

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

    Label no_mdo;

    if (ProfileInterpreter) {

      const Register Rmdo = Rscratch1;

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

      __ ld(Rmdo, in_bytes(Method::method_data_offset()), R19_method);

      __ cmpdi(CCR0, Rmdo, 0);

      __ beq(CCR0, no_mdo);

      // Increment backedge counter in the MDO.

      const int mdo_bc_offs = in_bytes(MethodData::backedge_counter_offset()) + in_bytes(InvocationCounter::counter_offset());

      __ lwz(Rscratch2, mdo_bc_offs, Rmdo);

      __ addi(Rscratch2, Rscratch2, increment);

      __ stw(Rscratch2, mdo_bc_offs, Rmdo);

      __ load_const_optimized(Rscratch1, mask, R0);

      __ and_(Rscratch1, Rscratch2, Rscratch1);

      __ bne(CCR0, done);

      __ b(*overflow);

    }

    // Increment counter in MethodCounters*.

    const int mo_bc_offs = in_bytes(MethodCounters::backedge_counter_offset()) + in_bytes(InvocationCounter::counter_offset());

    __ bind(no_mdo);

    __ get_method_counters(R19_method, R3_counters, done);

    __ lwz(Rscratch2, mo_bc_offs, R3_counters);

    __ addi(Rscratch2, Rscratch2, increment);

    __ stw(Rscratch2, mo_bc_offs, R3_counters);

    __ load_const_optimized(Rscratch1, mask, R0);

    __ and_(Rscratch1, Rscratch2, Rscratch1);

    __ beq(CCR0, *overflow);

    __ bind(done);

  } else {

    // Update standard invocation counters.

    Register Rsum_ivc_bec = R4_ARG2;

    __ get_method_counters(R19_method, R3_counters, done);

    __ increment_invocation_counter(R3_counters, Rsum_ivc_bec, R12_scratch2);

    // Increment interpreter invocation counter.

    if (ProfileInterpreter) {  // %%% Merge this into methodDataOop.

      __ lwz(R12_scratch2, in_bytes(MethodCounters::interpreter_invocation_counter_offset()), R3_counters);

      __ addi(R12_scratch2, R12_scratch2, 1);

      __ stw(R12_scratch2, in_bytes(MethodCounters::interpreter_invocation_counter_offset()), R3_counters);

    }

    // Check if we must create a method data obj.

    if (ProfileInterpreter && profile_method != NULL) {

      const Register profile_limit = Rscratch1;

      int pl_offs = __ load_const_optimized(profile_limit, &InvocationCounter::InterpreterProfileLimit, R0, true);

      __ lwz(profile_limit, pl_offs, profile_limit);

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

      __ cmpw(CCR0, Rsum_ivc_bec, profile_limit);

      __ blt(CCR0, *profile_method_continue);

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

      __ test_method_data_pointer(*profile_method);

    }

    // Finally check for counter overflow.

    if (overflow) {

      const Register invocation_limit = Rscratch1;

      int il_offs = __ load_const_optimized(invocation_limit, &InvocationCounter::InterpreterInvocationLimit, R0, true);

      __ lwz(invocation_limit, il_offs, invocation_limit);

      assert(4 == sizeof(InvocationCounter::InterpreterInvocationLimit), "unexpected field size");

      __ cmpw(CCR0, Rsum_ivc_bec, invocation_limit);

      __ bge(CCR0, *overflow);

    }

    __ bind(done);

  }

}

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

void TemplateInterpreterGenerator::generate_counter_overflow(Label& continue_entry) {

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

  // InterpreterRuntime::frequency_counter_overflow takes one arguments,

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

  // We pass zero in.

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

  //

  // Unlike the C++ interpreter above: Check exceptions!

  // Assumption: Caller must set the flag "do_not_unlock_if_sychronized" if the monitor of a sync'ed

  // method has not yet been created. Thus, no unlocking of a non-existing monitor can occur.

  __ li(R4_ARG2, 0);

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

  // Returns verified_entry_point or NULL.

  // We ignore it in any case.

  __ b(continue_entry);

}

void TemplateInterpreterGenerator::generate_stack_overflow_check(Register Rmem_frame_size, Register Rscratch1) {

  assert_different_registers(Rmem_frame_size, Rscratch1);

  __ generate_stack_overflow_check_with_compare_and_throw(Rmem_frame_size, Rscratch1);

}

void TemplateInterpreterGenerator::unlock_method(bool check_exceptions) {

  __ unlock_object(R26_monitor, check_exceptions);

}

// Lock the current method, interpreter register window must be set up!

void TemplateInterpreterGenerator::lock_method(Register Rflags, Register Rscratch1, Register Rscratch2, bool flags_preloaded) {

  const Register Robj_to_lock = Rscratch2;

  {

    if (!flags_preloaded) {

      __ lwz(Rflags, method_(access_flags));

    }

#ifdef ASSERT

    // Check if methods needs synchronization.

    {

      Label Lok;

      __ testbitdi(CCR0, R0, Rflags, JVM_ACC_SYNCHRONIZED_BIT);

      __ btrue(CCR0,Lok);

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

      __ bind(Lok);

    }

#endif // ASSERT

  }

  // Get synchronization object to Rscratch2.

  {

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

    Label Lstatic;

    Label Ldone;

    __ testbitdi(CCR0, R0, Rflags, JVM_ACC_STATIC_BIT);

    __ btrue(CCR0, Lstatic);

    // Non-static case: load receiver obj from stack and we're done.

    __ ld(Robj_to_lock, R18_locals);

    __ b(Ldone);

    __ bind(Lstatic); // Static case: Lock the java mirror

    __ ld(Robj_to_lock, in_bytes(Method::const_offset()), R19_method);

    __ ld(Robj_to_lock, in_bytes(ConstMethod::constants_offset()), Robj_to_lock);

    __ ld(Robj_to_lock, ConstantPool::pool_holder_offset_in_bytes(), Robj_to_lock);

    __ ld(Robj_to_lock, mirror_offset, Robj_to_lock);

    __ bind(Ldone);

    __ verify_oop(Robj_to_lock);

  }

  // Got the oop to lock => execute!

  __ add_monitor_to_stack(true, Rscratch1, R0);

  __ std(Robj_to_lock, BasicObjectLock::obj_offset_in_bytes(), R26_monitor);

  __ lock_object(R26_monitor, Robj_to_lock);

}

// Generate a fixed interpreter frame for pure interpreter

// and I2N native transition frames.

//

// Before (stack grows downwards):

//

//         |  ...         |

//         |------------- |

//         |  java arg0   |

//         |  ...         |

//         |  java argn   |

//         |              |   <-   R15_esp

//         |              |

//         |--------------|

//         | abi_112      |

//         |              |   <-   R1_SP

//         |==============|

//

//

// After:

//

//         |  ...         |

//         |  java arg0   |<-   R18_locals

//         |  ...         |

//         |  java argn   |

//         |--------------|

//         |              |

//         |  java locals |

//         |              |

//         |--------------|

//         |  abi_48      |

//         |==============|

//         |              |

//         |   istate     |

//         |              |

//         |--------------|

//         |   monitor    |<-   R26_monitor

//         |--------------|

//         |              |<-   R15_esp

//         | expression   |

//         | stack        |

//         |              |

//         |--------------|

//         |              |

//         | abi_112      |<-   R1_SP

//         |==============|

//

// The top most frame needs an abi space of 112 bytes. This space is needed,

// since we call to c. The c function may spill their arguments to the caller

// frame. When we call to java, we don't need these spill slots. In order to save

// space on the stack, we resize the caller. However, java local reside in

// the caller frame and the frame has to be increased. The frame_size for the

// current frame was calculated based on max_stack as size for the expression

// stack. At the call, just a part of the expression stack might be used.

// We don't want to waste this space and cut the frame back accordingly.

// The resulting amount for resizing is calculated as follows:

// resize =   (number_of_locals - number_of_arguments) * slot_size

//          + (R1_SP - R15_esp) + 48

//

// The size for the callee frame is calculated:

// framesize = 112 + max_stack + monitor + state_size

//

// maxstack:   Max number of slots on the expression stack, loaded from the method.

// monitor:    We statically reserve room for one monitor object.

// state_size: We save the current state of the interpreter to this area.

//

void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call, Register Rsize_of_parameters, Register Rsize_of_locals) {

  Register parent_frame_resize = R6_ARG4, // Frame will grow by this number of bytes.

           top_frame_size      = R7_ARG5,

           Rconst_method       = R8_ARG6;

  assert_different_registers(Rsize_of_parameters, Rsize_of_locals, parent_frame_resize, top_frame_size);

  __ ld(Rconst_method, method_(const));

  __ lhz(Rsize_of_parameters /* number of params */,

         in_bytes(ConstMethod::size_of_parameters_offset()), Rconst_method);

  if (native_call) {

    // If we're calling a native method, we reserve space for the worst-case signature

    // handler varargs vector, which is 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.

    Label skip_native_calculate_max_stack;

    __ addi(top_frame_size, Rsize_of_parameters, 2);

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

    __ bge(CCR0, skip_native_calculate_max_stack);

    __ li(top_frame_size, Argument::n_register_parameters);

    __ bind(skip_native_calculate_max_stack);

    __ sldi(Rsize_of_parameters, Rsize_of_parameters, Interpreter::logStackElementSize);

    __ sldi(top_frame_size, top_frame_size, Interpreter::logStackElementSize);

    __ sub(parent_frame_resize, R1_SP, R15_esp); // <0, off by Interpreter::stackElementSize!

    assert(Rsize_of_locals == noreg, "Rsize_of_locals not initialized"); // Only relevant value is Rsize_of_parameters.

  } else {

    __ lhz(Rsize_of_locals /* number of params */, in_bytes(ConstMethod::size_of_locals_offset()), Rconst_method);

    __ sldi(Rsize_of_parameters, Rsize_of_parameters, Interpreter::logStackElementSize);

    __ sldi(Rsize_of_locals, Rsize_of_locals, Interpreter::logStackElementSize);

    __ lhz(top_frame_size, in_bytes(ConstMethod::max_stack_offset()), Rconst_method);

    __ sub(R11_scratch1, Rsize_of_locals, Rsize_of_parameters); // >=0

    __ sub(parent_frame_resize, R1_SP, R15_esp); // <0, off by Interpreter::stackElementSize!

    __ sldi(top_frame_size, top_frame_size, Interpreter::logStackElementSize);

    __ add(parent_frame_resize, parent_frame_resize, R11_scratch1);

  }

  // Compute top frame size.

  __ addi(top_frame_size, top_frame_size, frame::abi_reg_args_size + frame::ijava_state_size);

  // Cut back area between esp and max_stack.

  __ addi(parent_frame_resize, parent_frame_resize, frame::abi_minframe_size - Interpreter::stackElementSize);

  __ round_to(top_frame_size, frame::alignment_in_bytes);

  __ round_to(parent_frame_resize, frame::alignment_in_bytes);

  // parent_frame_resize = (locals-parameters) - (ESP-SP-ABI48) Rounded to frame alignment size.

  // Enlarge by locals-parameters (not in case of native_call), shrink by ESP-SP-ABI48.

  {

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

    // Stack overflow check