/*

 * Copyright (c) 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"

#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.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"

#include "utilities/macros.hpp"

#ifndef CC_INTERP

#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::G1SATBCTLogging:

      {

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

#endif // INCLUDE_ALL_GCS

    case BarrierSet::CardTableModRef:

    case BarrierSet::CardTableExtension:

      {

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

#ifdef ASSERT

  // String and Object are rewritten to fast_aldc

  __ cmpdi(CCR0, Rscratch2, JVM_CONSTANT_Float);

  __ asm_assert_eq("unexpected type", 0x8765);

#endif

  __ lfsx(F15_ftos, Rcpool, Rscratch1);

  __ push(ftos);

  __ 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 resolved;

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

  __ cmpdi(CCR0, R17_tos, 0);

  __ bne(CCR0, resolved);

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

  __ align(32, 12);

  __ bind(resolved);

  __ verify_oop(R17_tos);

}

void TemplateTable::ldc2_w() {

  transition(vtos, vtos);

  Label Llong, Lexit;

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

  // A double can be placed at word-aligned locations in the constant pool.

  // Check out Conversions.java for an example.

  // Also ConstantPool::header_size() is 20, which makes it very difficult

  // to double-align double on the constant pool. SG, 11/7/97

  __ lfdx(F15_ftos, Rcpool, Rindex);

  __ push(dtos);

  __ b(Lexit);

  __ bind(Llong);

  __ ldx(R17_tos, Rcpool, Rindex);

  __ push(ltos);

  __ bind(Lexit);

}

// Get the locals index located in the bytecode stream at bcp + offset.

void TemplateTable::locals_index(Register Rdst, int offset) {

  __ lbz(Rdst, offset, R14_bcp);

}

void TemplateTable::iload() {

  iload_internal();

}

void TemplateTable::nofast_iload() {

  iload_internal(may_not_rewrite);

}

void TemplateTable::iload_internal(RewriteControl rc) {

  transition(vtos, itos);

  // Get the local value into tos

  const Register Rindex = R22_tmp2;

  locals_index(Rindex);

  // Rewrite iload,iload  pair into fast_iload2

  //         iload,caload pair into fast_icaload

  if (RewriteFrequentPairs && rc == may_rewrite) {

    Label Lrewrite, Ldone;

    Register Rnext_byte  = R3_ARG1,

             Rrewrite_to = R6_ARG4,

             Rscratch    = R11_scratch1;

    // get next byte

    __ lbz(Rnext_byte, Bytecodes::length_for(Bytecodes::_iload), R14_bcp);

    // if _iload, wait to rewrite to iload2. We only want to rewrite the

    // last two iloads in a pair. Comparing against fast_iload means that

    // the next bytecode is neither an iload or a caload, and therefore

    // an iload pair.

    __ cmpwi(CCR0, Rnext_byte, (unsigned int)(unsigned char)Bytecodes::_iload);

    __ beq(CCR0, Ldone);

    __ cmpwi(CCR1, Rnext_byte, (unsigned int)(unsigned char)Bytecodes::_fast_iload);

    __ li(Rrewrite_to, (unsigned int)(unsigned char)Bytecodes::_fast_iload2);

    __ beq(CCR1, Lrewrite);

    __ cmpwi(CCR0, Rnext_byte, (unsigned int)(unsigned char)Bytecodes::_caload);

    __ li(Rrewrite_to, (unsigned int)(unsigned char)Bytecodes::_fast_icaload);

    __ beq(CCR0, Lrewrite);

    __ li(Rrewrite_to, (unsigned int)(unsigned char)Bytecodes::_fast_iload);

    __ bind(Lrewrite);

    patch_bytecode(Bytecodes::_iload, Rrewrite_to, Rscratch, false);

    __ bind(Ldone);

  }

  __ load_local_int(R17_tos, Rindex, Rindex);

}

// Load 2 integers in a row without dispatching

void TemplateTable::fast_iload2() {

  transition(vtos, itos);

  __ lbz(R3_ARG1, 1, R14_bcp);

  __ lbz(R17_tos, Bytecodes::length_for(Bytecodes::_iload) + 1, R14_bcp);

  __ load_local_int(R3_ARG1, R11_scratch1, R3_ARG1);

  __ load_local_int(R17_tos, R12_scratch2, R17_tos);

  __ push_i(R3_ARG1);

}

void TemplateTable::fast_iload() {

  transition(vtos, itos);

  // Get the local value into tos

  const Register Rindex = R11_scratch1;

  locals_index(Rindex);

  __ load_local_int(R17_tos, Rindex, Rindex);

}

// Load a local variable type long from locals area to TOS cache register.

// Local index resides in bytecodestream.

void TemplateTable::lload() {

  transition(vtos, ltos);

  const Register Rindex = R11_scratch1;

  locals_index(Rindex);

  __ load_local_long(R17_tos, Rindex, Rindex);

}

void TemplateTable::fload() {

  transition(vtos, ftos);

  const Register Rindex = R11_scratch1;

  locals_index(Rindex);