/*

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

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/interp_masm.hpp"

#include "interpreter/templateTable.hpp"

#include "memory/universe.inline.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "prims/methodHandles.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,

                         Register base,

                         RegisterOrConstant offset,

                         Register val,

                         bool val_is_null, // == false does not guarantee that val really is not equal NULL.

                         Register tmp1,    // If tmp3 is volatile, either tmp1 or tmp2 must be

                         Register tmp2,    // non-volatile to hold a copy of pre_val across runtime calls.

                         Register tmp3,    // Ideally, this tmp register is non-volatile, as it is used to

                                           // hold pre_val (must survive runtime calls).

                         BarrierSet::Name barrier,

                         bool precise) {

  BLOCK_COMMENT("do_oop_store {");

  assert(val != noreg, "val must always be valid, even if it is zero");

  assert_different_registers(tmp1, tmp2, tmp3, val, base, offset.register_or_noreg());

  __ verify_oop(val);

  switch (barrier) {

#if INCLUDE_ALL_GCS

    case BarrierSet::G1SATBCTLogging:

      {

#ifdef ASSERT

        if (val_is_null) { // Check if the flag setting reflects reality.

          Label OK;

          __ z_ltgr(val, val);

          __ z_bre(OK);

          __ z_illtrap(0x11);

          __ bind(OK);

        }

#endif

        Register pre_val = tmp3;

        // Load and record the previous value.

        __ g1_write_barrier_pre(base, offset, pre_val, val,

                                tmp1, tmp2,

                                false);  // Needs to hold pre_val in non_volatile register?

        if (val_is_null) {

          __ store_heap_oop_null(val, offset, base);

        } else {

          Label Done;

          // val_is_null == false does not guarantee that val really is not equal NULL.

          // Checking for this case dynamically has some cost, but also some benefit (in GC).

          // It's hard to say if cost or benefit is greater.

          { Label OK;

            __ z_ltgr(val, val);

            __ z_brne(OK);

            __ store_heap_oop_null(val, offset, base);

            __ z_bru(Done);

            __ bind(OK);

          }

          // G1 barrier needs uncompressed oop for region cross check.

          // Store_heap_oop compresses the oop in the argument register.

          Register val_work = val;

          if (UseCompressedOops) {

            val_work = tmp3;

            __ z_lgr(val_work, val);

          }

          __ store_heap_oop_not_null(val_work, offset, base);

          // We need precise card marks for oop array stores.

          // Otherwise, cardmarking the object which contains the oop is sufficient.

          if (precise && !(offset.is_constant() && offset.as_constant() == 0)) {

            __ add2reg_with_index(base,

                                  offset.constant_or_zero(),

                                  offset.register_or_noreg(),

                                  base);

          }

          __ g1_write_barrier_post(base /* store_adr */, val, tmp1, tmp2, tmp3);

          __ bind(Done);

        }

      }

      break;

#endif // INCLUDE_ALL_GCS

    case BarrierSet::CardTableForRS:

    case BarrierSet::CardTableExtension:

    {

      if (val_is_null) {

        __ store_heap_oop_null(val, offset, base);

      } else {

        __ store_heap_oop(val, offset, base);

        // Flatten object address if needed.

        if (precise && ((offset.register_or_noreg() != noreg) || (offset.constant_or_zero() != 0))) {

          __ load_address(base, Address(base, offset.register_or_noreg(), offset.constant_or_zero()));

        }

        __ card_write_barrier_post(base, tmp1);

      }

    }

    break;

  case BarrierSet::ModRef:

    // fall through

  default:

    ShouldNotReachHere();

  }

  BLOCK_COMMENT("} do_oop_store");

}

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, 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);

#ifdef ASSERT

  {

    Label   L;

    __ z_cli(0, Raddr_type, JVM_CONSTANT_Integer);

    __ z_bre(L);

    // String and Object are rewritten to fast_aldc.

    __ stop("unexpected tag type in ldc");

    __ bind(L);

  }

#endif

  // itos

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

  __ push_i(Z_tos);

  __ bind(Done);