/*

 * Copyright (c) 1997, 2011, 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/templateTable.hpp"

#include "memory/universe.inline.hpp"

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

#ifndef CC_INTERP

#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) {

#ifndef SERIALGC

    case BarrierSet::G1SATBCT:

    case BarrierSet::G1SATBCTLogging:

      {

        // Load and record the previous value.

        __ g1_write_barrier_pre(base, index, offset,

                                noreg /* pre_val */,

                                tmp, true /*preserve_o_regs*/);

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

        }

      }

      break;

#endif // SERIALGC

    case BarrierSet::CardTableModRef:

    case BarrierSet::CardTableExtension:

      {

        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:

    case BarrierSet::Other:

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

}

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

  if (JvmtiExport::can_post_breakpoint()) {

    // perform the quickening, slowly, in the bowels of the breakpoint table

  }

#ifdef ASSERT

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

  __ delayed()->nop();

#endif

}

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

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

#ifdef _LP64

  __ set(value, Otos_l);

#else

  __ set(value, Otos_l2);

  __ clr( Otos_l1);

#endif

}

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 = constantPoolOopDesc::header_size() * wordSize;

  const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;

  // get type from tags

  __ add(O2, tags_offset, O2);

  __ ldub(O2, O1, O2);

  // unresolved string? If so, must resolve

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

  // 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::equal, true, Assembler::pt, isString);

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

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

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

  __ bind(isString);

  __ ld_ptr(O0, O1, Otos_i);

  __ verify_oop(Otos_i);

  __ push(atos);

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

  if (!EnableInvokeDynamic) {

    // We should not encounter this bytecode if !EnableInvokeDynamic.

    // The verifier will stop it.  However, if we get past the verifier,

    // this will stop the thread in a reasonable way, without crashing the JVM.

    __ call_VM(noreg, CAST_FROM_FN_PTR(address,

                     InterpreterRuntime::throw_IncompatibleClassChangeError));

    // the call_VM checks for exception, so we should never return here.

    __ should_not_reach_here();

    return;

  }

  Register Rcache = G3_scratch;

  Register Rscratch = G4_scratch;

  resolve_cache_and_index(f1_oop, Otos_i, Rcache, Rscratch, wide ? sizeof(u2) : sizeof(u1));

  __ verify_oop(Otos_i);

  Label L_done;

  const Register Rcon_klass = G3_scratch;  // same as Rcache

  const Register Rarray_klass = G4_scratch;  // same as Rscratch

  __ load_klass(Otos_i, Rcon_klass);

  AddressLiteral array_klass_addr((address)Universe::systemObjArrayKlassObj_addr());

  __ load_contents(array_klass_addr, Rarray_klass);

  __ cmp_and_brx_short(Rarray_klass, Rcon_klass, Assembler::notEqual, Assembler::pt, L_done);

  __ ld(Address(Otos_i, arrayOopDesc::length_offset_in_bytes()), Rcon_klass);

  __ tst(Rcon_klass);

  __ brx(Assembler::zero, true, Assembler::pt, L_done);

  __ delayed()->clr(Otos_i);    // executed only if branch is taken

  // Load the exception from the system-array which wraps it:

  __ load_heap_oop(Otos_i, arrayOopDesc::base_offset_in_bytes(T_OBJECT), Otos_i);

  __ throw_if_not_x(Assembler::never, Interpreter::throw_exception_entry(), G3_scratch);

  __ bind(L_done);

}

void TemplateTable::ldc2_w() {

  transition(vtos, vtos);

  Label retry, resolved, Long, exit;

  __ bind(retry);

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

  __ get_cpool_and_tags(O0, O2);

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

  const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;

  // 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 constantPoolOopDesc::header_size() is 20, which makes it very difficult

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

#ifdef _LP64

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

#else

  FloatRegister f = Ftos_d;

  __ ldf(FloatRegisterImpl::S, G3_scratch, base_offset, f);

  __ ldf(FloatRegisterImpl::S, G3_scratch, base_offset + sizeof(jdouble)/2,

         f->successor());

#endif

  __ push(dtos);

  __ ba_short(exit);

  __ bind(Long);

#ifdef _LP64

  __ ldx(G3_scratch, base_offset, Otos_l);

#else

  __ ld(G3_scratch, base_offset, Otos_l);

  __ ld(G3_scratch, base_offset + sizeof(jlong)/2, Otos_l->successor());

#endif

  __ 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() {

  transition(vtos, itos);

  // Rewrite iload,iload  pair into fast_iload2

  //         iload,caload pair into fast_icaload

  if (RewriteFrequentPairs) {

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

}