/*

 * Copyright (c) 1997, 2018, Oracle and/or its affiliates. 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 "interpreter/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/interp_masm.hpp"

#include "interpreter/templateTable.hpp"

#include "oops/methodData.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"

#define __ _masm->

// Misc helpers

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

// index can be noreg,

static void do_oop_store(InterpreterMacroAssembler* _masm,

                         Register base,

                         Register index,

                         int offset,

                         Register val,

                         Register tmp,

                         BarrierSet::Name barrier,

                         bool precise) {

  assert(tmp != val && tmp != base && tmp != index, "register collision");

  assert(index == noreg || offset == 0, "only one offset");

  switch (barrier) {

#if INCLUDE_ALL_GCS

    case BarrierSet::G1BarrierSet:

      {

        // Load and record the previous value.

        __ g1_write_barrier_pre(base, index, offset,

                                noreg /* pre_val */,

                                tmp, true /*preserve_o_regs*/);

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

        Register new_val = val;

        if (UseCompressedOops && val != G0) {

          new_val = tmp;

          __ mov(val, new_val);

        }

        if (index == noreg ) {

          assert(Assembler::is_simm13(offset), "fix this code");

          __ store_heap_oop(val, base, offset);

        } else {

          __ store_heap_oop(val, base, index);

        }

        // No need for post barrier if storing NULL

        if (val != G0) {

          if (precise) {

            if (index == noreg) {

              __ add(base, offset, base);

            } else {

              __ add(base, index, base);

            }

          }

          __ g1_write_barrier_post(base, new_val, tmp);

        }

      }

      break;

#endif // INCLUDE_ALL_GCS

    case BarrierSet::CardTableModRef:

      {

        if (index == noreg ) {

          assert(Assembler::is_simm13(offset), "fix this code");

          __ store_heap_oop(val, base, offset);

        } else {

          __ store_heap_oop(val, base, index);

        }

        // No need for post barrier if storing NULL

        if (val != G0) {

          if (precise) {

            if (index == noreg) {

              __ add(base, offset, base);

            } else {

              __ add(base, index, base);

            }

          }

          __ card_write_barrier_post(base, val, tmp);

        }

      }

      break;

    case BarrierSet::ModRef:

      ShouldNotReachHere();

      break;

    default      :

      ShouldNotReachHere();

  }

}

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

// Platform-dependent initialization

void TemplateTable::pd_initialize() {

  // (none)

}

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

// Condition conversion

Assembler::Condition ccNot(TemplateTable::Condition cc) {

  switch (cc) {

    case TemplateTable::equal        : return Assembler::notEqual;

    case TemplateTable::not_equal    : return Assembler::equal;

    case TemplateTable::less         : return Assembler::greaterEqual;

    case TemplateTable::less_equal   : return Assembler::greater;

    case TemplateTable::greater      : return Assembler::lessEqual;

    case TemplateTable::greater_equal: return Assembler::less;

  }

  ShouldNotReachHere();

  return Assembler::zero;

}

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

// Miscelaneous helper routines

Address TemplateTable::at_bcp(int offset) {

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

  return Address(Lbcp, offset);

}

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

                                   Register temp_reg, 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 (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(bc_reg, temp_reg, temp_reg, byte_no, 1);

      __ set(bc, bc_reg);

      __ cmp_and_br_short(temp_reg, 0, Assembler::equal, Assembler::pn, L_patch_done);  // don't patch

    }

    break;

  default:

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

    if (load_bc_into_bc_reg) {

      __ set(bc, bc_reg);

    }

  }

  if (JvmtiExport::can_post_breakpoint()) {

    Label L_fast_patch;

    __ ldub(at_bcp(0), temp_reg);

    __ cmp_and_br_short(temp_reg, Bytecodes::_breakpoint, Assembler::notEqual, Assembler::pt, 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), Lmethod, Lbcp, bc_reg);

    __ ba_short(L_patch_done);

    __ bind(L_fast_patch);

  }

#ifdef ASSERT

  Bytecodes::Code orig_bytecode =  Bytecodes::java_code(bc);

  Label L_okay;

  __ ldub(at_bcp(0), temp_reg);

  __ cmp(temp_reg, orig_bytecode);

  __ br(Assembler::equal, false, Assembler::pt, L_okay);

  __ delayed()->cmp(temp_reg, bc_reg);

  __ br(Assembler::equal, false, Assembler::pt, L_okay);

  __ delayed()->nop();

  __ stop("patching the wrong bytecode");

  __ bind(L_okay);

#endif

  // patch bytecode

  __ stb(bc_reg, at_bcp(0));

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

  __ clr(Otos_i);

}

void TemplateTable::iconst(int value) {

  transition(vtos, itos);

  __ set(value, Otos_i);

}

void TemplateTable::lconst(int value) {

  transition(vtos, ltos);

  assert(value >= 0, "check this code");

  __ set(value, Otos_l);

}

void TemplateTable::fconst(int value) {

  transition(vtos, ftos);

  static float zero = 0.0, one = 1.0, two = 2.0;

  float* p;

  switch( value ) {

   default: ShouldNotReachHere();

   case 0:  p = &zero;  break;

   case 1:  p = &one;   break;

   case 2:  p = &two;   break;

  }

  AddressLiteral a(p);

  __ sethi(a, G3_scratch);

  __ ldf(FloatRegisterImpl::S, G3_scratch, a.low10(), Ftos_f);

}

void TemplateTable::dconst(int value) {

  transition(vtos, dtos);

  static double zero = 0.0, one = 1.0;

  double* p;

  switch( value ) {

   default: ShouldNotReachHere();

   case 0:  p = &zero;  break;

   case 1:  p = &one;   break;

  }

  AddressLiteral a(p);

  __ sethi(a, G3_scratch);

  __ ldf(FloatRegisterImpl::D, G3_scratch, a.low10(), Ftos_d);

}

// %%%%% Should factore most snippet templates across platforms

void TemplateTable::bipush() {

  transition(vtos, itos);

  __ ldsb( at_bcp(1), Otos_i );

}

void TemplateTable::sipush() {

  transition(vtos, itos);

  __ get_2_byte_integer_at_bcp(1, G3_scratch, Otos_i, InterpreterMacroAssembler::Signed);

}

void TemplateTable::ldc(bool wide) {

  transition(vtos, vtos);

  Label call_ldc, notInt, isString, notString, notClass, exit;

  if (wide) {

    __ get_2_byte_integer_at_bcp(1, G3_scratch, O1, InterpreterMacroAssembler::Unsigned);

  } else {

    __ ldub(Lbcp, 1, O1);

  }

  __ get_cpool_and_tags(O0, O2);

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

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

  // get type from tags

  __ add(O2, tags_offset, O2);

  __ ldub(O2, O1, O2);

  // unresolved class? If so, must resolve

  __ cmp_and_brx_short(O2, JVM_CONSTANT_UnresolvedClass, Assembler::equal, Assembler::pt, call_ldc);

  // unresolved class in error state

  __ cmp_and_brx_short(O2, JVM_CONSTANT_UnresolvedClassInError, Assembler::equal, Assembler::pn, call_ldc);

  __ cmp(O2, JVM_CONSTANT_Class);      // need to call vm to get java mirror of the class

  __ brx(Assembler::notEqual, true, Assembler::pt, notClass);

  __ delayed()->add(O0, base_offset, O0);

  __ bind(call_ldc);

  __ set(wide, O1);

  call_VM(Otos_i, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), O1);

  __ push(atos);

  __ ba_short(exit);

  __ bind(notClass);

 // __ add(O0, base_offset, O0);

  __ sll(O1, LogBytesPerWord, O1);

  __ cmp(O2, JVM_CONSTANT_Integer);

  __ brx(Assembler::notEqual, true, Assembler::pt, notInt);

  __ delayed()->cmp(O2, JVM_CONSTANT_String);

  __ ld(O0, O1, Otos_i);

  __ push(itos);

  __ ba_short(exit);

  __ bind(notInt);

 // __ cmp(O2, JVM_CONSTANT_String);

  __ brx(Assembler::notEqual, true, Assembler::pt, notString);

  __ delayed()->ldf(FloatRegisterImpl::S, O0, O1, Ftos_f);

  __ bind(isString);

  __ stop("string should be rewritten to fast_aldc");

  __ ba_short(exit);

  __ bind(notString);

 // __ ldf(FloatRegisterImpl::S, O0, O1, Ftos_f);

  __ push(ftos);

  __ bind(exit);

}

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

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

  Label resolved;

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

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

  assert_different_registers(Otos_i, G3_scratch);

  __ get_cache_index_at_bcp(Otos_i, G3_scratch, 1, index_size);  // load index => G3_scratch

  __ load_resolved_reference_at_index(Otos_i, G3_scratch);

  __ tst(Otos_i);

  __ br(Assembler::notEqual, false, Assembler::pt, resolved);

  __ delayed()->set((int)bytecode(), O1);

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

  // first time invocation - must resolve first

  __ call_VM(Otos_i, entry, O1);

  __ bind(resolved);

  __ verify_oop(Otos_i);

}

void TemplateTable::ldc2_w() {

  transition(vtos, vtos);

  Label Long, exit;

  __ get_2_byte_integer_at_bcp(1, G3_scratch, O1, InterpreterMacroAssembler::Unsigned);

  __ get_cpool_and_tags(O0, O2);

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

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

  // get type from tags

  __ add(O2, tags_offset, O2);

  __ ldub(O2, O1, O2);

  __ sll(O1, LogBytesPerWord, O1);

  __ add(O0, O1, G3_scratch);

  __ cmp_and_brx_short(O2, JVM_CONSTANT_Double, Assembler::notEqual, Assembler::pt, Long);

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

  __ ldf(FloatRegisterImpl::D, G3_scratch, base_offset, Ftos_d);

  __ push(dtos);

  __ ba_short(exit);

  __ bind(Long);

  __ ldx(G3_scratch, base_offset, Otos_l);

  __ push(ltos);

  __ bind(exit);

}

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

  __ ldub( at_bcp(offset), reg );

}

void TemplateTable::locals_index_wide(Register reg) {

  // offset is 2, not 1, because Lbcp points to wide prefix code

  __ get_2_byte_integer_at_bcp(2, G4_scratch, reg, InterpreterMacroAssembler::Unsigned);

}

void TemplateTable::iload() {

  iload_internal();

}

void TemplateTable::nofast_iload() {

  iload_internal(may_not_rewrite);

}

void TemplateTable::iload_internal(RewriteControl rc) {

  transition(vtos, itos);

  // Rewrite iload,iload  pair into fast_iload2

  //         iload,caload pair into fast_icaload

  if (RewriteFrequentPairs && rc == may_rewrite) {

    Label rewrite, done;

    // get next byte

    __ ldub(at_bcp(Bytecodes::length_for(Bytecodes::_iload)), G3_scratch);

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

    __ cmp_and_br_short(G3_scratch, (int)Bytecodes::_iload, Assembler::equal, Assembler::pn, done);

    __ cmp(G3_scratch, (int)Bytecodes::_fast_iload);

    __ br(Assembler::equal, false, Assembler::pn, rewrite);

    __ delayed()->set(Bytecodes::_fast_iload2, G4_scratch);

    __ cmp(G3_scratch, (int)Bytecodes::_caload);

    __ br(Assembler::equal, false, Assembler::pn, rewrite);

    __ delayed()->set(Bytecodes::_fast_icaload, G4_scratch);

    __ set(Bytecodes::_fast_iload, G4_scratch);  // don't check again

    // rewrite

    // G4_scratch: fast bytecode

    __ bind(rewrite);

    patch_bytecode(Bytecodes::_iload, G4_scratch, G3_scratch, false);

    __ bind(done);

  }

  // Get the local value into tos

  locals_index(G3_scratch);

  __ access_local_int( G3_scratch, Otos_i );

}

void TemplateTable::fast_iload2() {

  transition(vtos, itos);

  locals_index(G3_scratch);

  __ access_local_int( G3_scratch, Otos_i );

  __ push_i();

  locals_index(G3_scratch, 3);  // get next bytecode's local index.

  __ access_local_int( G3_scratch, Otos_i );

}

void TemplateTable::fast_iload() {

  transition(vtos, itos);

  locals_index(G3_scratch);

  __ access_local_int( G3_scratch, Otos_i );

}

void TemplateTable::lload() {

  transition(vtos, ltos);

  locals_index(G3_scratch);

  __ access_local_long( G3_scratch, Otos_l );

}

void TemplateTable::fload() {

  transition(vtos, ftos);

  locals_index(G3_scratch);

  __ access_local_float( G3_scratch, Ftos_f );

}

void TemplateTable::dload() {

  transition(vtos, dtos);

  locals_index(G3_scratch);

  __ access_local_double( G3_scratch, Ftos_d );

}

void TemplateTable::aload() {

  transition(vtos, atos);

  locals_index(G3_scratch);

  __ access_local_ptr( G3_scratch, Otos_i);

}