/*

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

 * Copyright (c) 2016, 2017, SAP SE. 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 "interpreter/abstractInterpreter.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/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"

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

int TemplateInterpreter::InterpreterCodeSize = 320*K;

#undef  __

#ifdef PRODUCT

  #define __ _masm->

#else

  #define __ _masm->

//  #define __ (Verbose ? (_masm->block_comment(FILE_AND_LINE),_masm):_masm)->

#endif

#define BLOCK_COMMENT(str) __ block_comment(str)

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

#define oop_tmp_offset     _z_ijava_state_neg(oop_tmp)

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

address TemplateInterpreterGenerator::generate_slow_signature_handler() {

  //

  // New slow_signature handler that respects the z/Architecture

  // C calling conventions.

  //

  // We get called by the native entry code with our output register

  // area == 8. First we call InterpreterRuntime::get_result_handler

  // to copy the pointer to the signature string temporarily to the

  // first C-argument and to return the result_handler in

  // Z_RET. Since native_entry will copy the jni-pointer to the

  // first C-argument slot later on, it's OK to occupy this slot

  // temporarily. Then we copy the argument list on the java

  // expression stack into native varargs format on the native stack

  // and load arguments into argument registers. Integer arguments in

  // the varargs vector will be sign-extended to 8 bytes.

  //

  // On entry:

  //   Z_ARG1  - intptr_t*       Address of java argument list in memory.

  //   Z_state - cppInterpreter* Address of interpreter state for

  //                               this method

  //   Z_method

  //

  // On exit (just before return instruction):

  //   Z_RET contains the address of the result_handler.

  //   Z_ARG2 is not updated for static methods and contains "this" otherwise.

  //   Z_ARG3-Z_ARG5 contain the first 3 arguments of types other than float and double.

  //   Z_FARG1-Z_FARG4 contain the first 4 arguments of type float or double.

  const int LogSizeOfCase = 3;

  const int max_fp_register_arguments   = Argument::n_float_register_parameters;

  const int max_int_register_arguments  = Argument::n_register_parameters - 2;  // First 2 are reserved.

  const Register arg_java       = Z_tmp_2;

  const Register arg_c          = Z_tmp_3;

  const Register signature      = Z_R1_scratch; // Is a string.

  const Register fpcnt          = Z_R0_scratch;

  const Register argcnt         = Z_tmp_4;

  const Register intSlot        = Z_tmp_1;

  const Register sig_end        = Z_tmp_1; // Assumed end of signature (only used in do_object).

  const Register target_sp      = Z_tmp_1;

  const FloatRegister floatSlot = Z_F1;

  const int d_signature         = _z_abi(gpr6); // Only spill space, register contents not affected.

  const int d_fpcnt             = _z_abi(gpr7); // Only spill space, register contents not affected.

  unsigned int entry_offset = __ offset();

  BLOCK_COMMENT("slow_signature_handler {");

  // We use target_sp for storing arguments in the C frame.

  __ save_return_pc();

  __ push_frame_abi160(4*BytesPerWord);                 // Reserve space to save the tmp_[1..4] registers.

  __ z_stmg(Z_R10, Z_R13, frame::z_abi_160_size, Z_SP); // Save registers only after frame is pushed.

  __ z_lgr(arg_java, Z_ARG1);

  Register   method = Z_ARG2; // Directly load into correct argument register.

  __ get_method(method);

  __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::get_signature), Z_thread, method);

  // Move signature to callee saved register.

  // Don't directly write to stack. Frame is used by VM call.

  __ z_lgr(Z_tmp_1, Z_RET);

  // Reload method. Register may have been altered by VM call.

  __ get_method(method);

  // Get address of result handler.

  __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::get_result_handler), Z_thread, method);

  // Save signature address to stack.

  __ z_stg(Z_tmp_1, d_signature, Z_SP);

  // Don't overwrite return value (Z_RET, Z_ARG1) in rest of the method !

  {

    Label   isStatic;

    // Test if static.

    // We can test the bit directly.

    // Path is Z_method->_access_flags._flags.

    // We only support flag bits in the least significant byte (assert !).

    // Therefore add 3 to address that byte within "_flags".

    // Reload method. VM call above may have destroyed register contents

    __ get_method(method);

    __ testbit(method2_(method, access_flags), JVM_ACC_STATIC_BIT);

    method = noreg;  // end of life

    __ z_btrue(isStatic);

    // For non-static functions, pass "this" in Z_ARG2 and copy it to 2nd C-arg slot.

    // Need to box the Java object here, so we use arg_java

    // (address of current Java stack slot) as argument and

    // don't dereference it as in case of ints, floats, etc..

    __ z_lgr(Z_ARG2, arg_java);

    __ add2reg(arg_java, -BytesPerWord);

    __ bind(isStatic);

  }

  // argcnt == 0 corresponds to 3rd C argument.

  //   arg #1 (result handler) and

  //   arg #2 (this, for non-statics), unused else

  // are reserved and pre-filled above.

  // arg_java points to the corresponding Java argument here. It

  // has been decremented by one argument (this) in case of non-static.

  __ clear_reg(argcnt, true, false);  // Don't set CC.

  __ z_lg(target_sp, 0, Z_SP);

  __ add2reg(arg_c, _z_abi(remaining_cargs), target_sp);

  // No floating-point args parsed so far.

  __ clear_mem(Address(Z_SP, d_fpcnt), 8);

  NearLabel   move_intSlot_to_ARG, move_floatSlot_to_FARG;

  NearLabel   loop_start, loop_start_restore, loop_end;

  NearLabel   do_int, do_long, do_float, do_double;

  NearLabel   do_dontreachhere, do_object, do_array, do_boxed;

#ifdef ASSERT

  // Signature needs to point to '(' (== 0x28) at entry.

  __ z_lg(signature, d_signature, Z_SP);

  __ z_cli(0, signature, (int) '(');

  __ z_brne(do_dontreachhere);

#endif

  __ bind(loop_start_restore);

  __ z_lg(signature, d_signature, Z_SP);  // Restore signature ptr, destroyed by move_XX_to_ARG.

  BIND(loop_start);

  // Advance to next argument type token from the signature.

  __ add2reg(signature, 1);

  // Use CLI, works well on all CPU versions.

    __ z_cli(0, signature, (int) ')');

    __ z_bre(loop_end);                // end of signature

    __ z_cli(0, signature, (int) 'L');

    __ z_bre(do_object);               // object     #9

    __ z_cli(0, signature, (int) 'F');

    __ z_bre(do_float);                // float      #7

    __ z_cli(0, signature, (int) 'J');

    __ z_bre(do_long);                 // long       #6

    __ z_cli(0, signature, (int) 'B');

    __ z_bre(do_int);                  // byte       #1

    __ z_cli(0, signature, (int) 'Z');

    __ z_bre(do_int);                  // boolean    #2

    __ z_cli(0, signature, (int) 'C');

    __ z_bre(do_int);                  // char       #3

    __ z_cli(0, signature, (int) 'S');

    __ z_bre(do_int);                  // short      #4

    __ z_cli(0, signature, (int) 'I');

    __ z_bre(do_int);                  // int        #5

    __ z_cli(0, signature, (int) 'D');

    __ z_bre(do_double);               // double     #8

    __ z_cli(0, signature, (int) '[');

    __ z_bre(do_array);                // array      #10

  __ bind(do_dontreachhere);

  __ unimplemented("ShouldNotReachHere in slow_signature_handler", 120);

  // Array argument

  BIND(do_array);

  {

    Label   start_skip, end_skip;

    __ bind(start_skip);

    // Advance to next type tag from signature.

    __ add2reg(signature, 1);

    // Use CLI, works well on all CPU versions.

    __ z_cli(0, signature, (int) '[');

    __ z_bre(start_skip);               // Skip further brackets.

    __ z_cli(0, signature, (int) '9');

    __ z_brh(end_skip);                 // no optional size

    __ z_cli(0, signature, (int) '0');

    __ z_brnl(start_skip);              // Skip optional size.

    __ bind(end_skip);

    __ z_cli(0, signature, (int) 'L');

    __ z_brne(do_boxed);                // If not array of objects: go directly to do_boxed.

  }

  //  OOP argument

  BIND(do_object);

  // Pass by an object's type name.

  {

    Label   L;

    __ add2reg(sig_end, 4095, signature);     // Assume object type name is shorter than 4k.

    __ load_const_optimized(Z_R0, (int) ';'); // Type name terminator (must be in Z_R0!).

    __ MacroAssembler::search_string(sig_end, signature);

    __ z_brl(L);

    __ z_illtrap();  // No semicolon found: internal error or object name too long.

    __ bind(L);

    __ z_lgr(signature, sig_end);

    // fallthru to do_boxed

  }

  // Need to box the Java object here, so we use arg_java

  // (address of current Java stack slot) as argument and

  // don't dereference it as in case of ints, floats, etc..

  // UNBOX argument

  // Load reference and check for NULL.

  Label  do_int_Entry4Boxed;

  __ bind(do_boxed);

  {

    __ load_and_test_long(intSlot, Address(arg_java));

    __ z_bre(do_int_Entry4Boxed);

    __ z_lgr(intSlot, arg_java);

    __ z_bru(do_int_Entry4Boxed);

  }

  // INT argument

  // (also for byte, boolean, char, short)

  // Use lgf for load (sign-extend) and stg for store.

  BIND(do_int);

  __ z_lgf(intSlot, 0, arg_java);

  __ bind(do_int_Entry4Boxed);

  __ add2reg(arg_java, -BytesPerWord);

  // If argument fits into argument register, go and handle it, otherwise continue.

  __ compare32_and_branch(argcnt, max_int_register_arguments,

                          Assembler::bcondLow, move_intSlot_to_ARG);

  __ z_stg(intSlot, 0, arg_c);

  __ add2reg(arg_c, BytesPerWord);

  __ z_bru(loop_start);

  // LONG argument

  BIND(do_long);

  __ add2reg(arg_java, -2*BytesPerWord);  // Decrement first to have positive displacement for lg.

  __ z_lg(intSlot, BytesPerWord, arg_java);

  // If argument fits into argument register, go and handle it, otherwise continue.

  __ compare32_and_branch(argcnt, max_int_register_arguments,

                          Assembler::bcondLow, move_intSlot_to_ARG);

  __ z_stg(intSlot, 0, arg_c);

  __ add2reg(arg_c, BytesPerWord);

  __ z_bru(loop_start);

  // FLOAT argumen

  BIND(do_float);

  __ z_le(floatSlot, 0, arg_java);

  __ add2reg(arg_java, -BytesPerWord);

  assert(max_fp_register_arguments <= 255, "always true");  // safety net

  __ z_cli(d_fpcnt+7, Z_SP, max_fp_register_arguments);

  __ z_brl(move_floatSlot_to_FARG);

  __ z_ste(floatSlot, 4, arg_c);

  __ add2reg(arg_c, BytesPerWord);

  __ z_bru(loop_start);

  // DOUBLE argument

  BIND(do_double);

  __ add2reg(arg_java, -2*BytesPerWord);  // Decrement first to have positive displacement for lg.

  __ z_ld(floatSlot, BytesPerWord, arg_java);

  assert(max_fp_register_arguments <= 255, "always true");  // safety net

  __ z_cli(d_fpcnt+7, Z_SP, max_fp_register_arguments);

  __ z_brl(move_floatSlot_to_FARG);

  __ z_std(floatSlot, 0, arg_c);

  __ add2reg(arg_c, BytesPerWord);

  __ z_bru(loop_start);

  // Method exit, all arguments proocessed.

  __ bind(loop_end);

  __ z_lmg(Z_R10, Z_R13, frame::z_abi_160_size, Z_SP); // restore registers before frame is popped.

  __ pop_frame();

  __ restore_return_pc();

  __ z_br(Z_R14);

  // Copy int arguments.

  Label  iarg_caselist;   // Distance between each case has to be a power of 2

                          // (= 1 << LogSizeOfCase).

  __ align(16);

  BIND(iarg_caselist);

  __ z_lgr(Z_ARG3, intSlot);    // 4 bytes

  __ z_bru(loop_start_restore); // 4 bytes

  __ z_lgr(Z_ARG4, intSlot);

  __ z_bru(loop_start_restore);

  __ z_lgr(Z_ARG5, intSlot);

  __ z_bru(loop_start_restore);

  __ align(16);

  __ bind(move_intSlot_to_ARG);

  __ z_stg(signature, d_signature, Z_SP);       // Spill since signature == Z_R1_scratch.

  __ z_larl(Z_R1_scratch, iarg_caselist);

  __ z_sllg(Z_R0_scratch, argcnt, LogSizeOfCase);

  __ add2reg(argcnt, 1);

  __ z_agr(Z_R1_scratch, Z_R0_scratch);

  __ z_bcr(Assembler::bcondAlways, Z_R1_scratch);

  // Copy float arguments.

  Label  farg_caselist;   // Distance between each case has to be a power of 2

                          // (= 1 << logSizeOfCase, padded with nop.

  __ align(16);

  BIND(farg_caselist);

  __ z_ldr(Z_FARG1, floatSlot); // 2 bytes

  __ z_bru(loop_start_restore); // 4 bytes

  __ z_nop();                   // 2 bytes

  __ z_ldr(Z_FARG2, floatSlot);

  __ z_bru(loop_start_restore);

  __ z_nop();

  __ z_ldr(Z_FARG3, floatSlot);

  __ z_bru(loop_start_restore);

  __ z_nop();

  __ z_ldr(Z_FARG4, floatSlot);

  __ z_bru(loop_start_restore);

  __ z_nop();

  __ align(16);

  __ bind(move_floatSlot_to_FARG);

  __ z_stg(signature, d_signature, Z_SP);        // Spill since signature == Z_R1_scratch.

  __ z_lg(Z_R0_scratch, d_fpcnt, Z_SP);          // Need old value for indexing.

  __ add2mem_64(Address(Z_SP, d_fpcnt), 1, Z_R1_scratch); // Increment index.

  __ z_larl(Z_R1_scratch, farg_caselist);

  __ z_sllg(Z_R0_scratch, Z_R0_scratch, LogSizeOfCase);

  __ z_agr(Z_R1_scratch, Z_R0_scratch);

  __ z_bcr(Assembler::bcondAlways, Z_R1_scratch);

  BLOCK_COMMENT("} slow_signature_handler");

  return __ addr_at(entry_offset);

}

address TemplateInterpreterGenerator::generate_result_handler_for (BasicType type) {

  address entry = __ pc();

  assert(Z_tos == Z_RET, "Result handler: must move result!");

  assert(Z_ftos == Z_FRET, "Result handler: must move float result!");

  switch (type) {

    case T_BOOLEAN:

      __ c2bool(Z_tos);

      break;

    case T_CHAR:

      __ and_imm(Z_tos, 0xffff);

      break;

    case T_BYTE:

      __ z_lbr(Z_tos, Z_tos);

      break;

    case T_SHORT:

      __ z_lhr(Z_tos, Z_tos);

      break;

    case T_INT:

    case T_LONG:

    case T_VOID:

    case T_FLOAT:

    case T_DOUBLE:

      break;

    case T_OBJECT:

      // Retrieve result from frame...

      __ mem2reg_opt(Z_tos, Address(Z_fp, oop_tmp_offset));

      // and verify it.

      __ verify_oop(Z_tos);

      break;

    default:

      ShouldNotReachHere();

  }

  __ z_br(Z_R14);      // Return from result handler.

  return entry;

}

// Abstract method entry.

// Attempt to execute abstract method. Throw exception.

address TemplateInterpreterGenerator::generate_abstract_entry(void) {

  unsigned int entry_offset = __ offset();

  // Caller could be the call_stub or a compiled method (x86 version is wrong!).

  BLOCK_COMMENT("abstract_entry {");

  // Implement call of InterpreterRuntime::throw_AbstractMethodError.

  __ set_top_ijava_frame_at_SP_as_last_Java_frame(Z_SP, Z_R1);

  __ save_return_pc();       // Save Z_R14.

  __ push_frame_abi160(0);   // Without new frame the RT call could overwrite the saved Z_R14.

  __ pop_frame();

  __ restore_return_pc();    // Restore Z_R14.

  __ reset_last_Java_frame();

  // Restore caller sp for c2i case.

  __ resize_frame_absolute(Z_R10, Z_R0, true); // Cut the stack back to where the caller started.

  // branch to SharedRuntime::generate_forward_exception() which handles all possible callers,

  // i.e. call stub, compiled method, interpreted method.

  __ load_absolute_address(Z_tmp_1, StubRoutines::forward_exception_entry());

  __ z_br(Z_tmp_1);

  BLOCK_COMMENT("} abstract_entry");

  return __ addr_at(entry_offset);

}

address TemplateInterpreterGenerator::generate_Reference_get_entry(void) {

#if INCLUDE_ALL_GCS

  if (UseG1GC) {

    // Inputs:

    //  Z_ARG1 - receiver

    //

    // What we do:

    //  - Load the referent field address.

    //  - Load the value in the referent field.

    //  - Pass that value to the pre-barrier.

    //

    // In the case of G1 this will record the value of the

    // referent in an SATB buffer if marking is active.

    // This will cause concurrent marking to mark the referent

    // field as live.

    Register  scratch1 = Z_tmp_2;

    Register  scratch2 = Z_tmp_3;

    Register  pre_val  = Z_RET;   // return value

    // Z_esp is callers operand stack pointer, i.e. it points to the parameters.

    Register  Rargp    = Z_esp;

    Label     slow_path;

    address   entry = __ pc();

    const int referent_offset = java_lang_ref_Reference::referent_offset;

    guarantee(referent_offset > 0, "referent offset not initialized");

    BLOCK_COMMENT("Reference_get {");

    //  If the receiver is null then it is OK to jump to the slow path.

    __ load_and_test_long(pre_val, Address(Rargp, Interpreter::stackElementSize)); // Get receiver.

    __ z_bre(slow_path);

    //  Load the value of the referent field.

    __ load_heap_oop(pre_val, referent_offset, pre_val);

    // Restore caller sp for c2i case.

    __ resize_frame_absolute(Z_R10, Z_R0, true); // Cut the stack back to where the caller started.

    // Generate the G1 pre-barrier code to log the value of

    // the referent field in an SATB buffer.

    // Note:

    //   With these parameters the write_barrier_pre does not

    //   generate instructions to load the previous value.

    __ g1_write_barrier_pre(noreg,      // obj

                            noreg,      // offset