/*

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

 * Copyright (c) 2016, 2018 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 "gc/shared/barrierSetAssembler.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/interp_masm.hpp"

#include "interpreter/templateTable.hpp"

#include "memory/universe.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/safepointMechanism.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/synchronizer.hpp"

#ifdef PRODUCT

#define __ _masm->

#define BLOCK_COMMENT(str)

#define BIND(label)        __ bind(label);

#else

#define __ (PRODUCT_ONLY(false&&)Verbose ? (_masm->block_comment(FILE_AND_LINE),_masm):_masm)->

#define BLOCK_COMMENT(str) __ block_comment(str)

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

#endif

// The assumed minimum size of a BranchTableBlock.

// The actual size of each block heavily depends on the CPU capabilities and,

// of course, on the logic implemented in each block.

#ifdef ASSERT

  #define BTB_MINSIZE 256

#else

  #define BTB_MINSIZE  64

#endif

#ifdef ASSERT

// Macro to open a BranchTableBlock (a piece of code that is branched to by a calculated branch).

#define BTB_BEGIN(lbl, alignment, name)                                        \

  __ align_address(alignment);                                                 \

  __ bind(lbl);                                                                \

  { unsigned int b_off = __ offset();                                          \

    uintptr_t   b_addr = (uintptr_t)__ pc();                                   \

    __ z_larl(Z_R0, (int64_t)0);     /* Check current address alignment. */    \

    __ z_slgr(Z_R0, br_tab);         /* Current Address must be equal    */    \

    __ z_slgr(Z_R0, flags);          /* to calculated branch target.     */    \

    __ z_brc(Assembler::bcondLogZero, 3); /* skip trap if ok. */               \

    __ z_illtrap(0x55);                                                        \

    guarantee(b_addr%alignment == 0, "bad alignment at begin of block" name);

// Macro to close a BranchTableBlock (a piece of code that is branched to by a calculated branch).

#define BTB_END(lbl, alignment, name)                                          \

    uintptr_t   e_addr = (uintptr_t)__ pc();                                   \

    unsigned int e_off = __ offset();                                          \

    unsigned int len   = e_off-b_off;                                          \

    if (len > alignment) {                                                     \

      tty->print_cr("%4d of %4d @ " INTPTR_FORMAT ": Block len for %s",        \

                    len, alignment, e_addr-len, name);                         \

      guarantee(len <= alignment, "block too large");                          \

    }                                                                          \

    guarantee(len == e_addr-b_addr, "block len mismatch");                     \

  }

#else

// Macro to open a BranchTableBlock (a piece of code that is branched to by a calculated branch).

#define BTB_BEGIN(lbl, alignment, name)                                        \

  __ align_address(alignment);                                                 \

  __ bind(lbl);                                                                \

  { unsigned int b_off = __ offset();                                          \

    uintptr_t   b_addr = (uintptr_t)__ pc();                                   \

    guarantee(b_addr%alignment == 0, "bad alignment at begin of block" name);

// Macro to close a BranchTableBlock (a piece of code that is branched to by a calculated branch).

#define BTB_END(lbl, alignment, name)                                          \

    uintptr_t   e_addr = (uintptr_t)__ pc();                                   \

    unsigned int e_off = __ offset();                                          \

    unsigned int len   = e_off-b_off;                                          \

    if (len > alignment) {                                                     \

      tty->print_cr("%4d of %4d @ " INTPTR_FORMAT ": Block len for %s",        \

                    len, alignment, e_addr-len, name);                         \

      guarantee(len <= alignment, "block too large");                          \

    }                                                                          \

    guarantee(len == e_addr-b_addr, "block len mismatch");                     \

  }

#endif // ASSERT

// Platform-dependent initialization.

void TemplateTable::pd_initialize() {

  // No specific initialization.

}

// Address computation: local variables

static inline Address iaddress(int n) {

  return Address(Z_locals, Interpreter::local_offset_in_bytes(n));

}

static inline Address laddress(int n) {

  return iaddress(n + 1);

}

static inline Address faddress(int n) {

  return iaddress(n);

}

static inline Address daddress(int n) {

  return laddress(n);

}

static inline Address aaddress(int n) {

  return iaddress(n);

}

// Pass NULL, if no shift instruction should be emitted.

static inline Address iaddress(InterpreterMacroAssembler *masm, Register r) {

  if (masm) {

    masm->z_sllg(r, r, LogBytesPerWord);  // index2bytes

  }

  return Address(Z_locals, r, Interpreter::local_offset_in_bytes(0));

}

// Pass NULL, if no shift instruction should be emitted.

static inline Address laddress(InterpreterMacroAssembler *masm, Register r) {

  if (masm) {

    masm->z_sllg(r, r, LogBytesPerWord);  // index2bytes

  }

  return Address(Z_locals, r, Interpreter::local_offset_in_bytes(1) );

}

static inline Address faddress(InterpreterMacroAssembler *masm, Register r) {

  return iaddress(masm, r);

}

static inline Address daddress(InterpreterMacroAssembler *masm, Register r) {

  return laddress(masm, r);

}

static inline Address aaddress(InterpreterMacroAssembler *masm, Register r) {

  return iaddress(masm, r);

}

// At top of Java expression stack which may be different than esp(). It

// isn't for category 1 objects.

static inline Address at_tos(int slot = 0) {

  return Address(Z_esp, Interpreter::expr_offset_in_bytes(slot));

}

// Condition conversion

static Assembler::branch_condition j_not(TemplateTable::Condition cc) {

  switch (cc) {

    case TemplateTable::equal :

      return Assembler::bcondNotEqual;

    case TemplateTable::not_equal :

      return Assembler::bcondEqual;

    case TemplateTable::less :

      return Assembler::bcondNotLow;

    case TemplateTable::less_equal :

      return Assembler::bcondHigh;

    case TemplateTable::greater :

      return Assembler::bcondNotHigh;

    case TemplateTable::greater_equal:

      return Assembler::bcondLow;

  }

  ShouldNotReachHere();

  return Assembler::bcondZero;

}

// Do an oop store like *(base + offset) = val

// offset can be a register or a constant.

static void do_oop_store(InterpreterMacroAssembler* _masm,

                         const Address&     addr,

                         Register           val,         // Noreg means always null.

                         Register           tmp1,

                         Register           tmp2,

                         Register           tmp3,

                         DecoratorSet       decorators) {

  assert_different_registers(tmp1, tmp2, tmp3, val, addr.base());

  BarrierSetAssembler *bs = BarrierSet::barrier_set()->barrier_set_assembler();

  bs->store_at(_masm, decorators, T_OBJECT, addr, val, tmp1, tmp2, tmp3);

}

static void do_oop_load(InterpreterMacroAssembler* _masm,

                        const Address& addr,

                        Register dst,

                        Register tmp1,

                        Register tmp2,

                        DecoratorSet decorators) {

  assert_different_registers(addr.base(), tmp1, tmp2);

  assert_different_registers(dst, tmp1, tmp2);

  BarrierSetAssembler *bs = BarrierSet::barrier_set()->barrier_set_assembler();

  bs->load_at(_masm, decorators, T_OBJECT, addr, dst, tmp1, tmp2);

}

Address TemplateTable::at_bcp(int offset) {

  assert(_desc->uses_bcp(), "inconsistent uses_bcp information");

  return Address(Z_bcp, offset);

}

void TemplateTable::patch_bytecode(Bytecodes::Code bc,

                                   Register        bc_reg,

                                   Register        temp_reg,

                                   bool            load_bc_into_bc_reg, // = true

                                   int             byte_no) {

  if (!RewriteBytecodes) { return; }

  NearLabel L_patch_done;

  BLOCK_COMMENT("patch_bytecode {");

  switch (bc) {

    case Bytecodes::_fast_aputfield:

    case Bytecodes::_fast_bputfield:

    case Bytecodes::_fast_zputfield:

    case Bytecodes::_fast_cputfield:

    case Bytecodes::_fast_dputfield:

    case Bytecodes::_fast_fputfield:

    case Bytecodes::_fast_iputfield:

    case Bytecodes::_fast_lputfield:

    case Bytecodes::_fast_sputfield:

      {

        // We skip bytecode quickening for putfield instructions when

        // the put_code written to the constant pool cache is zero.

        // This is required so that every execution of this instruction

        // calls out to InterpreterRuntime::resolve_get_put to do

        // additional, required work.

        assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");

        assert(load_bc_into_bc_reg, "we use bc_reg as temp");

        __ get_cache_and_index_and_bytecode_at_bcp(Z_R1_scratch, bc_reg,

                                                   temp_reg, byte_no, 1);

        __ load_const_optimized(bc_reg, bc);

        __ compareU32_and_branch(temp_reg, (intptr_t)0,

                                 Assembler::bcondZero, L_patch_done);

      }

      break;

    default:

      assert(byte_no == -1, "sanity");

      // The pair bytecodes have already done the load.

      if (load_bc_into_bc_reg) {

        __ load_const_optimized(bc_reg, bc);

      }

      break;

  }

  if (JvmtiExport::can_post_breakpoint()) {

    Label   L_fast_patch;

    // If a breakpoint is present we can't rewrite the stream directly.

    __ z_cli(at_bcp(0), Bytecodes::_breakpoint);

    __ z_brne(L_fast_patch);

    __ get_method(temp_reg);

    // Let breakpoint table handling rewrite to quicker bytecode.

    __ call_VM_static(noreg,

                      CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at),

                      temp_reg, Z_R13, bc_reg);

    __ z_bru(L_patch_done);

    __ bind(L_fast_patch);

  }

#ifdef ASSERT

  NearLabel   L_okay;

  // We load into 64 bits, since this works on any CPU.

  __ z_llgc(temp_reg, at_bcp(0));

  __ compareU32_and_branch(temp_reg, Bytecodes::java_code(bc),

                            Assembler::bcondEqual, L_okay        );

  __ compareU32_and_branch(temp_reg, bc_reg, Assembler::bcondEqual, L_okay);

  __ stop_static("patching the wrong bytecode");

  __ bind(L_okay);

#endif

  // Patch bytecode.

  __ z_stc(bc_reg, at_bcp(0));

  __ bind(L_patch_done);

  BLOCK_COMMENT("} patch_bytecode");

}

// Individual instructions

void TemplateTable::nop() {

  transition(vtos, vtos);

}

void TemplateTable::shouldnotreachhere() {

  transition(vtos, vtos);

  __ stop("shouldnotreachhere bytecode");

}

void TemplateTable::aconst_null() {

  transition(vtos, atos);

  __ clear_reg(Z_tos, true, false);

}

void TemplateTable::iconst(int value) {

  transition(vtos, itos);

  // Zero extension of the iconst makes zero extension at runtime obsolete.

  __ load_const_optimized(Z_tos, ((unsigned long)(unsigned int)value));

}

void TemplateTable::lconst(int value) {

  transition(vtos, ltos);

  __ load_const_optimized(Z_tos, value);

}

// No pc-relative load/store for floats.

void TemplateTable::fconst(int value) {

  transition(vtos, ftos);

  static float   one = 1.0f, two = 2.0f;

  switch (value) {

    case 0:

      __ z_lzer(Z_ftos);

      return;

    case 1:

      __ load_absolute_address(Z_R1_scratch, (address) &one);

      __ mem2freg_opt(Z_ftos, Address(Z_R1_scratch), false);

      return;

    case 2:

      __ load_absolute_address(Z_R1_scratch, (address) &two);

      __ mem2freg_opt(Z_ftos, Address(Z_R1_scratch), false);

      return;

    default:

      ShouldNotReachHere();

      return;

  }

}

void TemplateTable::dconst(int value) {

  transition(vtos, dtos);

  static double one = 1.0;

  switch (value) {

    case 0:

      __ z_lzdr(Z_ftos);

      return;

    case 1:

      __ load_absolute_address(Z_R1_scratch, (address) &one);

      __ mem2freg_opt(Z_ftos, Address(Z_R1_scratch));

      return;

    default:

      ShouldNotReachHere();

      return;

  }

}

void TemplateTable::bipush() {

  transition(vtos, itos);

  __ z_lb(Z_tos, at_bcp(1));

}

void TemplateTable::sipush() {

  transition(vtos, itos);

  __ get_2_byte_integer_at_bcp(Z_tos, 1, InterpreterMacroAssembler::Signed);

}

void TemplateTable::ldc(bool wide) {

  transition(vtos, vtos);

  Label call_ldc, notFloat, notClass, notInt, Done;

  const Register RcpIndex = Z_tmp_1;

  const Register Rtags = Z_ARG2;

  if (wide) {

    __ get_2_byte_integer_at_bcp(RcpIndex, 1, InterpreterMacroAssembler::Unsigned);

  } else {

    __ z_llgc(RcpIndex, at_bcp(1));

  }

  __ get_cpool_and_tags(Z_tmp_2, Rtags);

  const int      base_offset = ConstantPool::header_size() * wordSize;

  const int      tags_offset = Array<u1>::base_offset_in_bytes();

  const Register Raddr_type = Rtags;

  // Get address of type.

  __ add2reg_with_index(Raddr_type, tags_offset, RcpIndex, Rtags);

  __ z_cli(0, Raddr_type, JVM_CONSTANT_UnresolvedClass);

  __ z_bre(call_ldc);    // Unresolved class - get the resolved class.

  __ z_cli(0, Raddr_type, JVM_CONSTANT_UnresolvedClassInError);

  __ z_bre(call_ldc);    // Unresolved class in error state - call into runtime

                         // to throw the error from the first resolution attempt.

  __ z_cli(0, Raddr_type, JVM_CONSTANT_Class);

  __ z_brne(notClass);   // Resolved class - need to call vm to get java

                         // mirror of the class.

  // We deal with a class. Call vm to do the appropriate.

  __ bind(call_ldc);

  __ load_const_optimized(Z_ARG2, wide);

  call_VM(Z_RET, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), Z_ARG2);

  __ push_ptr(Z_RET);

  __ z_bru(Done);

  // Not a class.

  __ bind(notClass);

  Register RcpOffset = RcpIndex;

  __ z_sllg(RcpOffset, RcpIndex, LogBytesPerWord); // Convert index to offset.

  __ z_cli(0, Raddr_type, JVM_CONSTANT_Float);

  __ z_brne(notFloat);

  // ftos

  __ mem2freg_opt(Z_ftos, Address(Z_tmp_2, RcpOffset, base_offset), false);

  __ push_f();

  __ z_bru(Done);

  __ bind(notFloat);

  __ z_cli(0, Raddr_type, JVM_CONSTANT_Integer);

  __ z_brne(notInt);

  // itos

  __ mem2reg_opt(Z_tos, Address(Z_tmp_2, RcpOffset, base_offset), false);

  __ push_i(Z_tos);

  __ z_bru(Done);

  // assume the tag is for condy; if not, the VM runtime will tell us

  __ bind(notInt);

  condy_helper(Done);

  __ bind(Done);

}

// Fast path for caching oop constants.

// %%% We should use this to handle Class and String constants also.

// %%% It will simplify the ldc/primitive path considerably.

void TemplateTable::fast_aldc(bool wide) {

  transition(vtos, atos);

  const Register index = Z_tmp_2;

  int            index_size = wide ? sizeof(u2) : sizeof(u1);

  Label          L_do_resolve, L_resolved;

  // We are resolved if the resolved reference cache entry contains a

  // non-null object (CallSite, etc.).

  __ get_cache_index_at_bcp(index, 1, index_size);  // Load index.

  __ load_resolved_reference_at_index(Z_tos, index);

  __ z_ltgr(Z_tos, Z_tos);

  __ z_bre(L_do_resolve);

  // Convert null sentinel to NULL.

  __ load_const_optimized(Z_R1_scratch, (intptr_t)Universe::the_null_sentinel_addr());

  __ z_cg(Z_tos, Address(Z_R1_scratch));

  __ z_brne(L_resolved);

  __ clear_reg(Z_tos);

  __ z_bru(L_resolved);

  __ bind(L_do_resolve);

  // First time invocation - must resolve first.

  address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);

  __ load_const_optimized(Z_ARG1, (int)bytecode());

  __ call_VM(Z_tos, entry, Z_ARG1);

  __ bind(L_resolved);

  __ verify_oop(Z_tos);

}

void TemplateTable::ldc2_w() {

  transition(vtos, vtos);

  Label notDouble, notLong, Done;

  // Z_tmp_1 = index of cp entry

  __ get_2_byte_integer_at_bcp(Z_tmp_1, 1, InterpreterMacroAssembler::Unsigned);

  __ get_cpool_and_tags(Z_tmp_2, Z_tos);

  const int base_offset = ConstantPool::header_size() * wordSize;

  const int tags_offset = Array<u1>::base_offset_in_bytes();

  // Get address of type.

  __ add2reg_with_index(Z_tos, tags_offset, Z_tos, Z_tmp_1);

  // Index needed in both branches, so calculate here.

  __ z_sllg(Z_tmp_1, Z_tmp_1, LogBytesPerWord);  // index2bytes

  // Check type.

  __ z_cli(0, Z_tos, JVM_CONSTANT_Double);

  __ z_brne(notDouble);

  // dtos

  __ mem2freg_opt(Z_ftos, Address(Z_tmp_2, Z_tmp_1, base_offset));

  __ push_d();

  __ z_bru(Done);

  __ bind(notDouble);

  __ z_cli(0, Z_tos, JVM_CONSTANT_Long);

  __ z_brne(notLong);

  // ltos

  __ mem2reg_opt(Z_tos, Address(Z_tmp_2, Z_tmp_1, base_offset));

  __ push_l();

  __ z_bru(Done);

  __ bind(notLong);

  condy_helper(Done);

  __ bind(Done);

}