/*

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

 * Copyright (c) 2014, Red Hat Inc. 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/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/interp_masm.hpp"

#include "interpreter/templateTable.hpp"

#include "memory/universe.hpp"

#include "oops/methodData.hpp"

#include "oops/method.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 aarch64 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 faddress(int n) {

  return iaddress(n);

}

static inline Address daddress(int n) {

  return laddress(n);

}

static inline Address aaddress(int n) {

  return iaddress(n);

}

static inline Address iaddress(Register r) {

  return Address(rlocals, r, Address::lsl(3));

}

static inline Address laddress(Register r, Register scratch,

                               InterpreterMacroAssembler* _masm) {

  __ lea(scratch, Address(rlocals, r, Address::lsl(3)));

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

}

static inline Address faddress(Register r) {

  return iaddress(r);

}

static inline Address daddress(Register r, Register scratch,

                               InterpreterMacroAssembler* _masm) {

  return laddress(r, scratch, _masm);

}

static inline Address aaddress(Register r) {

  return iaddress(r);

}

static inline Address at_rsp() {

  return Address(esp, 0);

}

// At top of Java expression stack which may be different than esp().  It

// isn't for category 1 objects.

static inline Address at_tos   () {

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

}

static inline Address at_tos_p1() {

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

}

static inline Address at_tos_p2() {

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

}

static inline Address at_tos_p3() {

  return Address(esp,  Interpreter::expr_offset_in_bytes(3));

}

static inline Address at_tos_p4() {

  return Address(esp,  Interpreter::expr_offset_in_bytes(4));

}

static inline Address at_tos_p5() {

  return Address(esp,  Interpreter::expr_offset_in_bytes(5));

}

// Condition conversion

static Assembler::Condition j_not(TemplateTable::Condition cc) {

  switch (cc) {

  case TemplateTable::equal        : return Assembler::NE;

  case TemplateTable::not_equal    : return Assembler::EQ;

  case TemplateTable::less         : return Assembler::GE;

  case TemplateTable::less_equal   : return Assembler::GT;

  case TemplateTable::greater      : return Assembler::LE;

  case TemplateTable::greater_equal: return Assembler::LT;

  }

  ShouldNotReachHere();

  return Assembler::EQ;

}

// Miscelaneous helper routines

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

// If val == noreg this means store a NULL

static void do_oop_store(InterpreterMacroAssembler* _masm,

                         Address dst,

                         Register val,

                         DecoratorSet decorators) {

  assert(val == noreg || val == r0, "parameter is just for looks");

  __ store_heap_oop(dst, val, r10, r1, decorators);

}

static void do_oop_load(InterpreterMacroAssembler* _masm,

                        Address src,

                        Register dst,

                        DecoratorSet decorators) {

  __ load_heap_oop(dst, src, r10, r1, decorators);

}

Address TemplateTable::at_bcp(int offset) {

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

  return Address(rbcp, offset);

}

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

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

                                   int byte_no)

{

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

      __ movw(bc_reg, bc);

      __ cbzw(temp_reg, L_patch_done);  // don't patch

    }

    break;

  default:

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

    // the pair bytecodes have already done the load.

    if (load_bc_into_bc_reg) {

      __ movw(bc_reg, bc);

    }

  }

  if (JvmtiExport::can_post_breakpoint()) {

    Label L_fast_patch;

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

    __ load_unsigned_byte(temp_reg, at_bcp(0));

    __ cmpw(temp_reg, Bytecodes::_breakpoint);

    __ br(Assembler::NE, L_fast_patch);

    // Let breakpoint table handling rewrite to quicker bytecode

    __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), rmethod, rbcp, bc_reg);

    __ b(L_patch_done);

    __ bind(L_fast_patch);

  }

#ifdef ASSERT

  Label L_okay;

  __ load_unsigned_byte(temp_reg, at_bcp(0));

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

  __ br(Assembler::EQ, L_okay);

  __ cmpw(temp_reg, bc_reg);

  __ br(Assembler::EQ, L_okay);

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

}

void TemplateTable::iconst(int value)

{

  transition(vtos, itos);

  __ mov(r0, value);

}

void TemplateTable::lconst(int value)

{

  __ mov(r0, value);

}

void TemplateTable::fconst(int value)

{

  transition(vtos, ftos);

  switch (value) {

  case 0:

    __ fmovs(v0, zr);

    break;

  case 1:

    __ fmovs(v0, 1.0);

    break;

  case 2:

    __ fmovs(v0, 2.0);

    break;

  default:

    ShouldNotReachHere();

    break;

  }

}

void TemplateTable::dconst(int value)

{

  transition(vtos, dtos);

  switch (value) {

  case 0:

    __ fmovd(v0, zr);

    break;

  case 1:

    __ fmovd(v0, 1.0);

    break;

  case 2:

    __ fmovd(v0, 2.0);

    break;

  default:

    ShouldNotReachHere();

    break;

  }

}

void TemplateTable::bipush()

{

  transition(vtos, itos);

  __ load_signed_byte32(r0, at_bcp(1));

}

void TemplateTable::sipush()

{

  transition(vtos, itos);

  __ load_unsigned_short(r0, at_bcp(1));

  __ revw(r0, r0);

  __ asrw(r0, r0, 16);

}

void TemplateTable::ldc(bool wide)

{

  transition(vtos, vtos);

  Label call_ldc, notFloat, notClass, notInt, Done;

  if (wide) {

    __ get_unsigned_2_byte_index_at_bcp(r1, 1);

  } else {

    __ load_unsigned_byte(r1, at_bcp(1));

  }

  __ get_cpool_and_tags(r2, r0);

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

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

  // get type

  __ add(r3, r1, tags_offset);

  __ lea(r3, Address(r0, r3));

  __ ldarb(r3, r3);

  // unresolved class - get the resolved class

  __ cmp(r3, (u1)JVM_CONSTANT_UnresolvedClass);

  __ br(Assembler::EQ, call_ldc);

  // unresolved class in error state - call into runtime to throw the error

  // from the first resolution attempt

  __ cmp(r3, (u1)JVM_CONSTANT_UnresolvedClassInError);

  __ br(Assembler::EQ, call_ldc);

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

  __ cmp(r3, (u1)JVM_CONSTANT_Class);

  __ br(Assembler::NE, notClass);

  __ bind(call_ldc);

  __ mov(c_rarg1, wide);

  call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), c_rarg1);

  __ push_ptr(r0);

  __ verify_oop(r0);

  __ b(Done);

  __ bind(notClass);

  __ cmp(r3, (u1)JVM_CONSTANT_Float);

  __ br(Assembler::NE, notFloat);

  // ftos

  __ adds(r1, r2, r1, Assembler::LSL, 3);

  __ ldrs(v0, Address(r1, base_offset));

  __ push_f();

  __ b(Done);

  __ bind(notFloat);

  __ cmp(r3, (u1)JVM_CONSTANT_Integer);

  __ br(Assembler::NE, notInt);

  // itos

  __ adds(r1, r2, r1, Assembler::LSL, 3);

  __ ldrw(r0, Address(r1, base_offset));

  __ push_i(r0);

  __ b(Done);

  __ bind(notInt);

  condy_helper(Done);

  __ bind(Done);

}

// Fast path for caching oop constants.

void TemplateTable::fast_aldc(bool wide)

{

  transition(vtos, atos);

  Register result = r0;

  Register tmp = r1;

  Register rarg = r2;

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

  Label resolved;

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

  // non-null object (String, MethodType, etc.)

  assert_different_registers(result, tmp);

  __ get_cache_index_at_bcp(tmp, 1, index_size);

  __ load_resolved_reference_at_index(result, tmp);

  __ cbnz(result, resolved);

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

  // first time invocation - must resolve first

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

  __ call_VM(result, entry, rarg);

  __ bind(resolved);

  { // Check for the null sentinel.

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

    // but it's harmless to retry.

    Label notNull;

    // Stash null_sentinel address to get its value later

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

    __ ldr(tmp, Address(rarg));

    __ cmpoop(result, tmp);

    __ br(Assembler::NE, notNull);

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

    __ bind(notNull);

  }

  if (VerifyOops) {

    // Safe to call with 0 result

    __ verify_oop(result);

  }

}

void TemplateTable::ldc2_w()

{

  transition(vtos, vtos);

  Label notDouble, notLong, Done;

  __ get_unsigned_2_byte_index_at_bcp(r0, 1);

  __ get_cpool_and_tags(r1, r2);

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

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

  // get type

  __ lea(r2, Address(r2, r0, Address::lsl(0)));

  __ load_unsigned_byte(r2, Address(r2, tags_offset));

  __ cmpw(r2, (int)JVM_CONSTANT_Double);

  __ br(Assembler::NE, notDouble);

  // dtos

  __ lea (r2, Address(r1, r0, Address::lsl(3)));

  __ ldrd(v0, Address(r2, base_offset));

  __ push_d();

  __ b(Done);

  __ bind(notDouble);

  __ cmpw(r2, (int)JVM_CONSTANT_Long);

  __ br(Assembler::NE, notLong);

  // ltos

  __ lea(r0, Address(r1, r0, Address::lsl(3)));

  __ ldr(r0, Address(r0, base_offset));

  __ push_l();

  __ b(Done);

  __ bind(notLong);

  condy_helper(Done);

  __ bind(Done);

}

void TemplateTable::condy_helper(Label& Done)

{

  Register obj = r0;

  Register rarg = r1;

  Register flags = r2;

  Register off = r3;

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

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

  __ call_VM(obj, entry, rarg);

  __ get_vm_result_2(flags, rthread);

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

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

  __ mov(off, flags);

  __ andw(off, off, ConstantPoolCacheEntry::field_index_mask);

  const Address field(obj, off);

  // What sort of thing are we loading?

  // x86 uses a shift and mask or wings it with a shift plus assert

  // the mask is not needed. aarch64 just uses bitfield extract

  __ ubfxw(flags, flags, ConstantPoolCacheEntry::tos_state_shift,

           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;

        __ cmpw(flags, itos);

        __ br(Assembler::NE, notInt);

        // itos

        __ ldrw(r0, field);

        __ push(itos);

        __ b(Done);

        __ bind(notInt);

        __ cmpw(flags, ftos);

        __ br(Assembler::NE, notFloat);

        // ftos

        __ load_float(field);

        __ push(ftos);

        __ b(Done);

        __ bind(notFloat);

        __ cmpw(flags, stos);

        __ br(Assembler::NE, notShort);

        // stos