/*

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

 * Copyright (c) 2013, 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/templateInterpreter.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"

#include "utilities/macros.hpp"

#undef __

#define __ _masm->

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

// Misc helpers

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

// (only one of both variants is possible at the same time).

// Index can be noreg.

// Kills:

//   Rbase, Rtmp

static void do_oop_store(InterpreterMacroAssembler* _masm,

                         Register           Rbase,

                         RegisterOrConstant offset,

                         Register           Rval,         // Noreg means always null.

                         Register           Rtmp1,

                         Register           Rtmp2,

                         Register           Rtmp3,

                         BarrierSet::Name   barrier,

                         bool               precise,

                         bool               check_null) {

  assert_different_registers(Rtmp1, Rtmp2, Rtmp3, Rval, Rbase);

  switch (barrier) {

#if INCLUDE_ALL_GCS

    case BarrierSet::G1BarrierSet:

      {

        // Load and record the previous value.

        __ g1_write_barrier_pre(Rbase, offset,

                                Rtmp3, /* holder of pre_val ? */

                                Rtmp1, Rtmp2, false /* frame */);

        Label Lnull, Ldone;

        if (Rval != noreg) {

          if (check_null) {

            __ cmpdi(CCR0, Rval, 0);

            __ beq(CCR0, Lnull);

          }

          __ store_heap_oop_not_null(Rval, offset, Rbase, /*Rval must stay uncompressed.*/ Rtmp1);

          // Mark the card.

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

            __ add(Rbase, offset, Rbase);

          }

          __ g1_write_barrier_post(Rbase, Rval, Rtmp1, Rtmp2, Rtmp3, /*filtered (fast path)*/ &Ldone);

          if (check_null) { __ b(Ldone); }

        }

        if (Rval == noreg || check_null) { // Store null oop.

          Register Rnull = Rval;

          __ bind(Lnull);

          if (Rval == noreg) {

            Rnull = Rtmp1;

            __ li(Rnull, 0);

          }

          if (UseCompressedOops) {

            __ stw(Rnull, offset, Rbase);

          } else {

            __ std(Rnull, offset, Rbase);

          }

        }

        __ bind(Ldone);

      }

      break;

    case BarrierSet::Epsilon:

      Unimplemented(); // Should look like CardTableModRef without card marks?

      break;

#endif // INCLUDE_ALL_GCS

    case BarrierSet::CardTableBarrierSet:

      {

        Label Lnull, Ldone;

        if (Rval != noreg) {

          if (check_null) {

            __ cmpdi(CCR0, Rval, 0);

            __ beq(CCR0, Lnull);

          }

          __ store_heap_oop_not_null(Rval, offset, Rbase, /*Rval should better stay uncompressed.*/ Rtmp1);

          // Mark the card.

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

            __ add(Rbase, offset, Rbase);

          }

          __ card_write_barrier_post(Rbase, Rval, Rtmp1);

          if (check_null) {

            __ b(Ldone);

          }

        }

        if (Rval == noreg || check_null) { // Store null oop.

          Register Rnull = Rval;

          __ bind(Lnull);

          if (Rval == noreg) {

            Rnull = Rtmp1;

            __ li(Rnull, 0);

          }

          if (UseCompressedOops) {

            __ stw(Rnull, offset, Rbase);

          } else {

            __ std(Rnull, offset, Rbase);

          }

        }

        __ bind(Ldone);

      }

      break;

    case BarrierSet::ModRef:

      ShouldNotReachHere();

      break;

    default:

      ShouldNotReachHere();

  }

}

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

// Platform-dependent initialization

void TemplateTable::pd_initialize() {

  // No ppc64 specific initialization.

}

Address TemplateTable::at_bcp(int offset) {

  // Not used on ppc.

  ShouldNotReachHere();

  return Address();

}

// Patches the current bytecode (ptr to it located in bcp)

// in the bytecode stream with a new one.

void TemplateTable::patch_bytecode(Bytecodes::Code new_bc, Register Rnew_bc, Register Rtemp, bool load_bc_into_bc_reg /*=true*/, int byte_no) {

  // With sharing on, may need to test method flag.

  if (!RewriteBytecodes) return;

  Label L_patch_done;

  switch (new_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_at_bcp(Rtemp /* dst = cache */, 1);

      // ((*(cache+indices))>>((1+byte_no)*8))&0xFF:

#if defined(VM_LITTLE_ENDIAN)

      __ lbz(Rnew_bc, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::indices_offset()) + 1 + byte_no, Rtemp);

#else

      __ lbz(Rnew_bc, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::indices_offset()) + 7 - (1 + byte_no), Rtemp);

#endif

      __ cmpwi(CCR0, Rnew_bc, 0);

      __ li(Rnew_bc, (unsigned int)(unsigned char)new_bc);

      __ beq(CCR0, L_patch_done);

      // __ isync(); // acquire not needed

      break;

    }

    default:

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

      if (load_bc_into_bc_reg) {

        __ li(Rnew_bc, (unsigned int)(unsigned char)new_bc);

      }

  }

  if (JvmtiExport::can_post_breakpoint()) {

    Label L_fast_patch;

    __ lbz(Rtemp, 0, R14_bcp);

    __ cmpwi(CCR0, Rtemp, (unsigned int)(unsigned char)Bytecodes::_breakpoint);

    __ bne(CCR0, L_fast_patch);

    // Perform the quickening, slowly, in the bowels of the breakpoint table.

    __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), R19_method, R14_bcp, Rnew_bc);

    __ b(L_patch_done);

    __ bind(L_fast_patch);

  }

  // Patch bytecode.

  __ stb(Rnew_bc, 0, R14_bcp);

  __ bind(L_patch_done);

}

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

// Individual instructions

void TemplateTable::nop() {

  transition(vtos, vtos);

  // Nothing to do.

}

void TemplateTable::shouldnotreachhere() {

  transition(vtos, vtos);

  __ stop("shouldnotreachhere bytecode");

}

void TemplateTable::aconst_null() {

  transition(vtos, atos);

  __ li(R17_tos, 0);

}

void TemplateTable::iconst(int value) {

  transition(vtos, itos);

  assert(value >= -1 && value <= 5, "");

  __ li(R17_tos, value);

}

void TemplateTable::lconst(int value) {

  transition(vtos, ltos);

  assert(value >= -1 && value <= 5, "");

  __ li(R17_tos, value);

}

void TemplateTable::fconst(int value) {

  transition(vtos, ftos);

  static float zero = 0.0;

  static float one  = 1.0;

  static float two  = 2.0;

  switch (value) {

    default: ShouldNotReachHere();

    case 0: {

      int simm16_offset = __ load_const_optimized(R11_scratch1, (address*)&zero, R0, true);

      __ lfs(F15_ftos, simm16_offset, R11_scratch1);

      break;

    }

    case 1: {

      int simm16_offset = __ load_const_optimized(R11_scratch1, (address*)&one, R0, true);

      __ lfs(F15_ftos, simm16_offset, R11_scratch1);

      break;

    }

    case 2: {

      int simm16_offset = __ load_const_optimized(R11_scratch1, (address*)&two, R0, true);

      __ lfs(F15_ftos, simm16_offset, R11_scratch1);

      break;

    }

  }

}

void TemplateTable::dconst(int value) {

  transition(vtos, dtos);

  static double zero = 0.0;

  static double one  = 1.0;

  switch (value) {

    case 0: {

      int simm16_offset = __ load_const_optimized(R11_scratch1, (address*)&zero, R0, true);

      __ lfd(F15_ftos, simm16_offset, R11_scratch1);

      break;

    }

    case 1: {

      int simm16_offset = __ load_const_optimized(R11_scratch1, (address*)&one, R0, true);

      __ lfd(F15_ftos, simm16_offset, R11_scratch1);

      break;

    }

    default: ShouldNotReachHere();

  }

}

void TemplateTable::bipush() {

  transition(vtos, itos);

  __ lbz(R17_tos, 1, R14_bcp);

  __ extsb(R17_tos, R17_tos);

}

void TemplateTable::sipush() {

  transition(vtos, itos);

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

}

void TemplateTable::ldc(bool wide) {

  Register Rscratch1 = R11_scratch1,

           Rscratch2 = R12_scratch2,

           Rcpool    = R3_ARG1;

  transition(vtos, vtos);

  Label notInt, notFloat, notClass, exit;

  __ get_cpool_and_tags(Rcpool, Rscratch2); // Set Rscratch2 = &tags.

  if (wide) { // Read index.

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

  } else {

    __ lbz(Rscratch1, 1, R14_bcp);

  }

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

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

  // Get type from tags.

  __ addi(Rscratch2, Rscratch2, tags_offset);

  __ lbzx(Rscratch2, Rscratch2, Rscratch1);

  __ cmpwi(CCR0, Rscratch2, JVM_CONSTANT_UnresolvedClass); // Unresolved class?

  __ cmpwi(CCR1, Rscratch2, JVM_CONSTANT_UnresolvedClassInError); // Unresolved class in error state?

  __ cror(CCR0, Assembler::equal, CCR1, Assembler::equal);

  // Resolved class - need to call vm to get java mirror of the class.

  __ cmpwi(CCR1, Rscratch2, JVM_CONSTANT_Class);

  __ crnor(CCR0, Assembler::equal, CCR1, Assembler::equal); // Neither resolved class nor unresolved case from above?

  __ beq(CCR0, notClass);

  __ li(R4, wide ? 1 : 0);

  call_VM(R17_tos, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), R4);

  __ push(atos);

  __ b(exit);

  __ align(32, 12);

  __ bind(notClass);

  __ addi(Rcpool, Rcpool, base_offset);

  __ sldi(Rscratch1, Rscratch1, LogBytesPerWord);

  __ cmpdi(CCR0, Rscratch2, JVM_CONSTANT_Integer);

  __ bne(CCR0, notInt);

  __ lwax(R17_tos, Rcpool, Rscratch1);

  __ push(itos);

  __ b(exit);

  __ align(32, 12);

  __ bind(notInt);

  __ cmpdi(CCR0, Rscratch2, JVM_CONSTANT_Float);

  __ bne(CCR0, notFloat);

  __ lfsx(F15_ftos, Rcpool, Rscratch1);

  __ push(ftos);

  __ b(exit);

  __ align(32, 12);

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

  __ bind(notFloat);

  condy_helper(exit);

  __ align(32, 12);

  __ bind(exit);

}

// Fast path for caching oop constants.

void TemplateTable::fast_aldc(bool wide) {

  transition(vtos, atos);

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

  const Register Rscratch = R11_scratch1;

  Label is_null;

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

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

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

  __ load_resolved_reference_at_index(R17_tos, Rscratch, &is_null);

  // Convert null sentinel to NULL.

  int simm16_rest = __ load_const_optimized(Rscratch, Universe::the_null_sentinel_addr(), R0, true);

  __ ld(Rscratch, simm16_rest, Rscratch);

  __ cmpld(CCR0, R17_tos, Rscratch);

  if (VM_Version::has_isel()) {

    __ isel_0(R17_tos, CCR0, Assembler::equal);

  } else {

    Label not_sentinel;

    __ bne(CCR0, not_sentinel);

    __ li(R17_tos, 0);

    __ bind(not_sentinel);

  }

  __ verify_oop(R17_tos);

  __ dispatch_epilog(atos, Bytecodes::length_for(bytecode()));

  __ bind(is_null);

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

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

  // First time invocation - must resolve first.

  __ call_VM(R17_tos, entry, R3_ARG1);

  __ verify_oop(R17_tos);

}

void TemplateTable::ldc2_w() {

  transition(vtos, vtos);

  Label not_double, not_long, exit;

  Register Rindex = R11_scratch1,

           Rcpool = R12_scratch2,

           Rtag   = R3_ARG1;

  __ get_cpool_and_tags(Rcpool, Rtag);

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

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

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

  // Get type from tags.

  __ addi(Rcpool, Rcpool, base_offset);

  __ addi(Rtag, Rtag, tags_offset);

  __ lbzx(Rtag, Rtag, Rindex);

  __ sldi(Rindex, Rindex, LogBytesPerWord);

  __ cmpdi(CCR0, Rtag, JVM_CONSTANT_Double);

  __ bne(CCR0, not_double);

  __ lfdx(F15_ftos, Rcpool, Rindex);

  __ push(dtos);

  __ b(exit);

  __ bind(not_double);

  __ cmpdi(CCR0, Rtag, JVM_CONSTANT_Long);

  __ bne(CCR0, not_long);

  __ ldx(R17_tos, Rcpool, Rindex);

  __ push(ltos);

  __ b(exit);

  __ bind(not_long);

  condy_helper(exit);

  __ align(32, 12);

  __ bind(exit);

}

void TemplateTable::condy_helper(Label& Done) {

  const Register obj   = R31;

  const Register off   = R11_scratch1;

  const Register flags = R12_scratch2;

  const Register rarg  = R4_ARG2;

  __ li(rarg, (int)bytecode());

  call_VM(obj, CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc), rarg);

  __ get_vm_result_2(flags);

  // VMr = obj = base address to find primitive value to push

  // VMr2 = flags = (tos, off) using format of CPCE::_flags

  __ andi(off, flags, ConstantPoolCacheEntry::field_index_mask);

  // What sort of thing are we loading?

  __ rldicl(flags, flags, 64-ConstantPoolCacheEntry::tos_state_shift, 64-ConstantPoolCacheEntry::tos_state_bits);

  switch (bytecode()) {

  case Bytecodes::_ldc:

  case Bytecodes::_ldc_w:

    {

      // tos in (itos, ftos, stos, btos, ctos, ztos)

      Label notInt, notFloat, notShort, notByte, notChar, notBool;

      __ cmplwi(CCR0, flags, itos);

      __ bne(CCR0, notInt);

      // itos

      __ lwax(R17_tos, obj, off);

      __ push(itos);

      __ b(Done);

      __ bind(notInt);

      __ cmplwi(CCR0, flags, ftos);

      __ bne(CCR0, notFloat);

      // ftos

      __ lfsx(F15_ftos, obj, off);

      __ push(ftos);

      __ b(Done);

      __ bind(notFloat);

      __ cmplwi(CCR0, flags, stos);

      __ bne(CCR0, notShort);

      // stos

      __ lhax(R17_tos, obj, off);

      __ push(stos);

      __ b(Done);

      __ bind(notShort);

      __ cmplwi(CCR0, flags, btos);

      __ bne(CCR0, notByte);

      // btos

      __ lbzx(R17_tos, obj, off);

      __ extsb(R17_tos, R17_tos);

      __ push(btos);

      __ b(Done);

      __ bind(notByte);

      __ cmplwi(CCR0, flags, ctos);

      __ bne(CCR0, notChar);

      // ctos

      __ lhzx(R17_tos, obj, off);

      __ push(ctos);

      __ b(Done);