/*

 * Copyright (c) 2008, 2019, 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 "asm/macroAssembler.inline.hpp"

#include "gc/shared/barrierSetAssembler.hpp"

#include "interpreter/interp_masm.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/templateTable.hpp"

#include "memory/universe.hpp"

#include "oops/cpCache.hpp"

#include "oops/methodData.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/synchronizer.hpp"

#define __ _masm->

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

// Platform-dependent initialization

void TemplateTable::pd_initialize() {

  // No arm specific initialization

}

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

// Address computation

// local variables

static inline Address iaddress(int n)            {

  return Address(Rlocals, Interpreter::local_offset_in_bytes(n));

}

static inline Address laddress(int n)            { return iaddress(n + 1); }

static inline Address haddress(int n)            { return iaddress(n + 0); }

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

void TemplateTable::get_local_base_addr(Register r, Register index) {

  __ sub(r, Rlocals, AsmOperand(index, lsl, Interpreter::logStackElementSize));

}

Address TemplateTable::load_iaddress(Register index, Register scratch) {

  return Address(Rlocals, index, lsl, Interpreter::logStackElementSize, basic_offset, sub_offset);

}

Address TemplateTable::load_aaddress(Register index, Register scratch) {

  return load_iaddress(index, scratch);

}

Address TemplateTable::load_faddress(Register index, Register scratch) {

#ifdef __SOFTFP__

  return load_iaddress(index, scratch);

#else

  get_local_base_addr(scratch, index);

  return Address(scratch);

#endif // __SOFTFP__

}

Address TemplateTable::load_daddress(Register index, Register scratch) {

  get_local_base_addr(scratch, index);

  return Address(scratch, Interpreter::local_offset_in_bytes(1));

}

// At top of Java expression stack which may be different than SP.

// It isn't for category 1 objects.

static inline Address at_tos() {

  return Address(Rstack_top, Interpreter::expr_offset_in_bytes(0));

}

static inline Address at_tos_p1() {

  return Address(Rstack_top, Interpreter::expr_offset_in_bytes(1));

}

static inline Address at_tos_p2() {

  return Address(Rstack_top, Interpreter::expr_offset_in_bytes(2));

}

// Loads double/long local into R0_tos_lo/R1_tos_hi with two

// separate ldr instructions (supports nonadjacent values).

// Used for longs in all modes, and for doubles in SOFTFP mode.

void TemplateTable::load_category2_local(Register Rlocal_index, Register tmp) {

  const Register Rlocal_base = tmp;

  assert_different_registers(Rlocal_index, tmp);

  get_local_base_addr(Rlocal_base, Rlocal_index);

  __ ldr(R0_tos_lo, Address(Rlocal_base, Interpreter::local_offset_in_bytes(1)));

  __ ldr(R1_tos_hi, Address(Rlocal_base, Interpreter::local_offset_in_bytes(0)));

}

// Stores R0_tos_lo/R1_tos_hi to double/long local with two

// separate str instructions (supports nonadjacent values).

// Used for longs in all modes, and for doubles in SOFTFP mode

void TemplateTable::store_category2_local(Register Rlocal_index, Register tmp) {

  const Register Rlocal_base = tmp;

  assert_different_registers(Rlocal_index, tmp);

  get_local_base_addr(Rlocal_base, Rlocal_index);

  __ str(R0_tos_lo, Address(Rlocal_base, Interpreter::local_offset_in_bytes(1)));

  __ str(R1_tos_hi, Address(Rlocal_base, Interpreter::local_offset_in_bytes(0)));

}

// Returns address of Java array element using temp register as address base.

Address TemplateTable::get_array_elem_addr(BasicType elemType, Register array, Register index, Register temp) {

  int logElemSize = exact_log2(type2aelembytes(elemType));

  __ add_ptr_scaled_int32(temp, array, index, logElemSize);

  return Address(temp, arrayOopDesc::base_offset_in_bytes(elemType));

}

// Returns address of Java array element using temp register as offset from array base

Address TemplateTable::get_array_elem_addr_same_base(BasicType elemType, Register array, Register index, Register temp) {

  int logElemSize = exact_log2(type2aelembytes(elemType));

  if (logElemSize == 0) {

    __ add(temp, index, arrayOopDesc::base_offset_in_bytes(elemType));

  } else {

    __ mov(temp, arrayOopDesc::base_offset_in_bytes(elemType));

    __ add_ptr_scaled_int32(temp, temp, index, logElemSize);

  }

  return Address(array, temp);

}

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

// Condition conversion

AsmCondition convNegCond(TemplateTable::Condition cc) {

  switch (cc) {

    case TemplateTable::equal        : return ne;

    case TemplateTable::not_equal    : return eq;

    case TemplateTable::less         : return ge;

    case TemplateTable::less_equal   : return gt;

    case TemplateTable::greater      : return le;

    case TemplateTable::greater_equal: return lt;

  }

  ShouldNotReachHere();

  return nv;

}

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

// Miscelaneous helper routines

// Store an oop (or NULL) at the address described by obj.

// Blows all volatile registers R0-R3, Rtemp, LR).

// Also destroys new_val and obj.base().

static void do_oop_store(InterpreterMacroAssembler* _masm,

                         Address obj,

                         Register new_val,

                         Register tmp1,

                         Register tmp2,

                         Register tmp3,

                         bool is_null,

                         DecoratorSet decorators = 0) {

  assert_different_registers(obj.base(), new_val, tmp1, tmp2, tmp3, noreg);

  if (is_null) {

    __ store_heap_oop_null(obj, new_val, tmp1, tmp2, tmp3, decorators);

  } else {

    __ store_heap_oop(obj, new_val, tmp1, tmp2, tmp3, decorators);

  }

}

static void do_oop_load(InterpreterMacroAssembler* _masm,

                        Register dst,

                        Address obj,

                        DecoratorSet decorators = 0) {

  __ load_heap_oop(dst, obj, noreg, noreg, noreg, decorators);

}

Address TemplateTable::at_bcp(int offset) {

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

  return Address(Rbcp, offset);

}

// Blows volatile registers R0-R3, Rtemp, LR.

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

                                   Register temp_reg, bool load_bc_into_bc_reg/*=true*/,

                                   int byte_no) {

  assert_different_registers(bc_reg, temp_reg);

  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, sizeof(u2));

      __ mov(bc_reg, bc);

      __ cbz(temp_reg, L_patch_done);  // test if bytecode is zero

    }

    break;

  default:

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

    // the pair bytecodes have already done the load.

    if (load_bc_into_bc_reg) {

      __ mov(bc_reg, bc);

    }

  }

  if (__ can_post_breakpoint()) {

    Label L_fast_patch;

    // if a breakpoint is present we can't rewrite the stream directly

    __ ldrb(temp_reg, at_bcp(0));

    __ cmp(temp_reg, Bytecodes::_breakpoint);

    __ b(L_fast_patch, ne);

    if (bc_reg != R3) {

      __ mov(R3, bc_reg);

    }

    __ mov(R1, Rmethod);

    __ mov(R2, Rbcp);

    // Let breakpoint table handling rewrite to quicker bytecode

    __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), R1, R2, R3);

    __ b(L_patch_done);

    __ bind(L_fast_patch);

  }

#ifdef ASSERT

  Label L_okay;

  __ ldrb(temp_reg, at_bcp(0));

  __ cmp(temp_reg, (int)Bytecodes::java_code(bc));

  __ b(L_okay, eq);

  __ cmp(temp_reg, bc_reg);

  __ b(L_okay, eq);

  __ stop("patching the wrong bytecode");

  __ bind(L_okay);

#endif

  // patch bytecode

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

  __ mov(R0_tos, 0);

}

void TemplateTable::iconst(int value) {

  transition(vtos, itos);

  __ mov_slow(R0_tos, value);

}

void TemplateTable::lconst(int value) {

  transition(vtos, ltos);

  assert((value == 0) || (value == 1), "unexpected long constant");

  __ mov(R0_tos, value);

  __ mov(R1_tos_hi, 0);

}

void TemplateTable::fconst(int value) {

  transition(vtos, ftos);

  const int zero = 0;         // 0.0f

  const int one = 0x3f800000; // 1.0f

  const int two = 0x40000000; // 2.0f

  switch(value) {

  case 0:   __ mov(R0_tos, zero);   break;

  case 1:   __ mov(R0_tos, one);    break;

  case 2:   __ mov(R0_tos, two);    break;

  default:  ShouldNotReachHere();   break;

  }

#ifndef __SOFTFP__

  __ fmsr(S0_tos, R0_tos);

#endif // !__SOFTFP__

}

void TemplateTable::dconst(int value) {

  transition(vtos, dtos);

  const int one_lo = 0;            // low part of 1.0

  const int one_hi = 0x3ff00000;   // high part of 1.0

  if (value == 0) {

#ifdef __SOFTFP__

    __ mov(R0_tos_lo, 0);

    __ mov(R1_tos_hi, 0);

#else

    __ mov(R0_tmp, 0);

    __ fmdrr(D0_tos, R0_tmp, R0_tmp);

#endif // __SOFTFP__

  } else if (value == 1) {

    __ mov(R0_tos_lo, one_lo);

    __ mov_slow(R1_tos_hi, one_hi);

#ifndef __SOFTFP__

    __ fmdrr(D0_tos, R0_tos_lo, R1_tos_hi);

#endif // !__SOFTFP__

  } else {

    ShouldNotReachHere();

  }

}

void TemplateTable::bipush() {

  transition(vtos, itos);

  __ ldrsb(R0_tos, at_bcp(1));

}

void TemplateTable::sipush() {

  transition(vtos, itos);

  __ ldrsb(R0_tmp, at_bcp(1));

  __ ldrb(R1_tmp, at_bcp(2));

  __ orr(R0_tos, R1_tmp, AsmOperand(R0_tmp, lsl, BitsPerByte));

}

void TemplateTable::ldc(bool wide) {

  transition(vtos, vtos);

  Label fastCase, Condy, Done;

  const Register Rindex = R1_tmp;

  const Register Rcpool = R2_tmp;

  const Register Rtags  = R3_tmp;

  const Register RtagType = R3_tmp;

  if (wide) {

    __ get_unsigned_2_byte_index_at_bcp(Rindex, 1);

  } else {

    __ ldrb(Rindex, at_bcp(1));

  }

  __ get_cpool_and_tags(Rcpool, Rtags);

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

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

  // get const type

  __ add(Rtemp, Rtags, tags_offset);

  __ ldrb(RtagType, Address(Rtemp, Rindex));

  volatile_barrier(MacroAssembler::LoadLoad, Rtemp);

  // unresolved class - get the resolved class

  __ cmp(RtagType, JVM_CONSTANT_UnresolvedClass);

  // unresolved class in error (resolution failed) - call into runtime

  // so that the same error from first resolution attempt is thrown.

  __ cond_cmp(RtagType, JVM_CONSTANT_UnresolvedClassInError, ne);

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

  __ cond_cmp(RtagType, JVM_CONSTANT_Class, ne);

  __ b(fastCase, ne);

  // slow case - call runtime

  __ mov(R1, wide);

  call_VM(R0_tos, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), R1);

  __ push(atos);

  __ b(Done);

  // int, float, String

  __ bind(fastCase);

  __ cmp(RtagType, JVM_CONSTANT_Integer);

  __ cond_cmp(RtagType, JVM_CONSTANT_Float, ne);

  __ b(Condy, ne);

  // itos, ftos

  __ add(Rtemp, Rcpool, AsmOperand(Rindex, lsl, LogBytesPerWord));

  __ ldr_u32(R0_tos, Address(Rtemp, base_offset));

  // floats and ints are placed on stack in the same way, so

  // we can use push(itos) to transfer float value without VFP

  __ push(itos);

  __ b(Done);

  __ bind(Condy);

  condy_helper(Done);

  __ bind(Done);

}

// Fast path for caching oop constants.

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(R0_tos, R2_tmp);

  __ get_index_at_bcp(R2_tmp, 1, R0_tos, index_size);

  __ load_resolved_reference_at_index(R0_tos, R2_tmp);

  __ cbnz(R0_tos, resolved);

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

  // first time invocation - must resolve first

  __ mov(R1, (int)bytecode());

  __ call_VM(R0_tos, entry, R1);

  __ bind(resolved);

  { // Check for the null sentinel.

    // If we just called the VM, that already did the mapping for us,

    // but it's harmless to retry.

    Label notNull;

    Register result = R0;

    Register tmp = R1;

    Register rarg = R2;

    // Stash null_sentinel address to get its value later

    __ mov_slow(rarg, (uintptr_t)Universe::the_null_sentinel_addr());

    __ ldr(tmp, Address(rarg));

    __ cmp(result, tmp);

    __ b(notNull, ne);

    __ mov(result, 0);  // NULL object reference

    __ bind(notNull);

  }

  if (VerifyOops) {

    __ verify_oop(R0_tos);

  }

}

void TemplateTable::ldc2_w() {

  transition(vtos, vtos);

  const Register Rtags  = R2_tmp;

  const Register Rindex = R3_tmp;

  const Register Rcpool = R4_tmp;

  const Register Rbase  = R5_tmp;

  __ get_unsigned_2_byte_index_at_bcp(Rindex, 1);

  __ get_cpool_and_tags(Rcpool, Rtags);

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

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

  __ add(Rbase, Rcpool, AsmOperand(Rindex, lsl, LogBytesPerWord));

  Label Condy, exit;

#ifdef __ABI_HARD__

  Label Long;

  // get type from tags

  __ add(Rtemp, Rtags, tags_offset);

  __ ldrb(Rtemp, Address(Rtemp, Rindex));

  __ cmp(Rtemp, JVM_CONSTANT_Double);

  __ b(Long, ne);

  __ ldr_double(D0_tos, Address(Rbase, base_offset));

  __ push(dtos);

  __ b(exit);

  __ bind(Long);

#endif

  __ cmp(Rtemp, JVM_CONSTANT_Long);

  __ b(Condy, ne);

  __ ldr(R0_tos_lo, Address(Rbase, base_offset + 0 * wordSize));

  __ ldr(R1_tos_hi, Address(Rbase, base_offset + 1 * wordSize));

  __ push(ltos);

  __ b(exit);

  __ bind(Condy);

  condy_helper(exit);

  __ bind(exit);

}

void TemplateTable::condy_helper(Label& Done)

{

  Register obj   = R0_tmp;