/*

 * 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 "asm/macroAssembler.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/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/safepointMechanism.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/synchronizer.hpp"

#include "utilities/macros.hpp"

#define __ _masm->

// Global Register Names

static const Register rbcp     = LP64_ONLY(r13) NOT_LP64(rsi);

static const Register rlocals  = LP64_ONLY(r14) NOT_LP64(rdi);

// Platform-dependent initialization

void TemplateTable::pd_initialize() {

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

}

#ifndef _LP64

static inline Address haddress(int n) {

  return iaddress(n + 0);

}

#endif

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

}

static inline Address laddress(Register r) {

  return Address(rlocals, r, Address::times_ptr, Interpreter::local_offset_in_bytes(1));

}

#ifndef _LP64

static inline Address haddress(Register r)       {

  return Address(rlocals, r, Interpreter::stackElementScale(), Interpreter::local_offset_in_bytes(0));

}

#endif

static inline Address faddress(Register r) {

  return iaddress(r);

}

static inline Address daddress(Register r) {

  return laddress(r);

}

static inline Address aaddress(Register r) {

  return iaddress(r);

}

// expression stack

// (Note: Must not use symmetric equivalents at_rsp_m1/2 since they store

// data beyond the rsp which is potentially unsafe in an MT environment;

// an interrupt may overwrite that data.)

static inline Address at_rsp   () {

  return Address(rsp, 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(rsp,  Interpreter::expr_offset_in_bytes(0));

}

static inline Address at_tos_p1() {

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

}

static inline Address at_tos_p2() {

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

}

// Condition conversion

static Assembler::Condition j_not(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

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

                         Register val,

                         BarrierSet::Name barrier,

                         bool precise) {

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

  switch (barrier) {

#if INCLUDE_ALL_GCS

    case BarrierSet::G1BarrierSet:

      {

        // flatten object address if needed

        // We do it regardless of precise because we need the registers

        if (obj.index() == noreg && obj.disp() == 0) {

          if (obj.base() != rdx) {

            __ movptr(rdx, obj.base());

          }

        } else {

          __ lea(rdx, obj);

        }

        Register rtmp    = LP64_ONLY(r8)         NOT_LP64(rsi);

        Register rthread = LP64_ONLY(r15_thread) NOT_LP64(rcx);

        NOT_LP64(__ get_thread(rcx));

        NOT_LP64(__ save_bcp());

        __ g1_write_barrier_pre(rdx /* obj */,

                                rbx /* pre_val */,

                                rthread /* thread */,

                                rtmp  /* tmp */,

                                val != noreg /* tosca_live */,

                                false /* expand_call */);

        if (val == noreg) {

          __ store_heap_oop_null(Address(rdx, 0));

        } else {

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

          Register new_val = val;

          if (UseCompressedOops) {

            new_val = rbx;

            __ movptr(new_val, val);

          }

          __ store_heap_oop(Address(rdx, 0), val);

          __ g1_write_barrier_post(rdx /* store_adr */,

                                   new_val /* new_val */,

                                   rthread /* thread */,

                                   rtmp /* tmp */,

                                   rbx /* tmp2 */);

        }

        NOT_LP64( __ restore_bcp());

      }

      break;

#endif // INCLUDE_ALL_GCS

      {

        if (val == noreg) {

          __ store_heap_oop_null(obj);

        } else {

          __ store_heap_oop(obj, val);

          // flatten object address if needed

          if (!precise || (obj.index() == noreg && obj.disp() == 0)) {

            __ store_check(obj.base());

          } else {

            __ lea(rdx, obj);

            __ store_check(rdx);

          }

        }

      }

      break;

    case BarrierSet::ModRef:

      if (val == noreg) {

        __ store_heap_oop_null(obj);

      } else {

        __ store_heap_oop(obj, val);

      }

      break;

    default      :

      ShouldNotReachHere();

  }

}

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

      __ movl(bc_reg, bc);

      __ cmpl(temp_reg, (int) 0);

      __ jcc(Assembler::zero, 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) {

      __ movl(bc_reg, bc);

    }

  }

  if (JvmtiExport::can_post_breakpoint()) {

    Label L_fast_patch;

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

    __ movzbl(temp_reg, at_bcp(0));

    __ cmpl(temp_reg, Bytecodes::_breakpoint);

    __ jcc(Assembler::notEqual, L_fast_patch);

    __ get_method(temp_reg);

    // Let breakpoint table handling rewrite to quicker bytecode

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

#ifndef ASSERT

    __ jmpb(L_patch_done);

#else

    __ jmp(L_patch_done);

#endif

    __ bind(L_fast_patch);

  }

#ifdef ASSERT

  Label L_okay;

  __ load_unsigned_byte(temp_reg, at_bcp(0));

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

  __ jcc(Assembler::equal, L_okay);

  __ cmpl(temp_reg, bc_reg);

  __ jcc(Assembler::equal, L_okay);

  __ stop("patching the wrong bytecode");

  __ bind(L_okay);

#endif

  // patch bytecode

  __ movb(at_bcp(0), bc_reg);

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

  __ xorl(rax, rax);

}

void TemplateTable::iconst(int value) {

  transition(vtos, itos);

  if (value == 0) {

    __ xorl(rax, rax);

  } else {

    __ movl(rax, value);

  }

}

void TemplateTable::lconst(int value) {

  transition(vtos, ltos);

  if (value == 0) {

    __ xorl(rax, rax);

  } else {

    __ movl(rax, value);

  }

#ifndef _LP64

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

  __ xorptr(rdx, rdx);

#endif

}

void TemplateTable::fconst(int value) {

  transition(vtos, ftos);

  if (UseSSE >= 1) {

    static float one = 1.0f, two = 2.0f;

    switch (value) {

    case 0:

      __ xorps(xmm0, xmm0);

      break;

    case 1:

      __ movflt(xmm0, ExternalAddress((address) &one));

      break;

    case 2:

      __ movflt(xmm0, ExternalAddress((address) &two));

      break;

    default:

      ShouldNotReachHere();

      break;

    }

  } else {

#ifdef _LP64

    ShouldNotReachHere();

#else

           if (value == 0) { __ fldz();

    } else if (value == 1) { __ fld1();

    } else if (value == 2) { __ fld1(); __ fld1(); __ faddp(); // should do a better solution here

    } else                 { ShouldNotReachHere();

    }

#endif // _LP64

  }

}

void TemplateTable::dconst(int value) {

  transition(vtos, dtos);

  if (UseSSE >= 2) {

    static double one = 1.0;

    switch (value) {

    case 0:

      __ xorpd(xmm0, xmm0);

      break;

    case 1:

      __ movdbl(xmm0, ExternalAddress((address) &one));

      break;

    default:

      ShouldNotReachHere();

      break;

    }

  } else {

#ifdef _LP64

    ShouldNotReachHere();

#else

           if (value == 0) { __ fldz();

    } else if (value == 1) { __ fld1();

    } else                 { ShouldNotReachHere();

    }

#endif

  }

}

void TemplateTable::bipush() {

  transition(vtos, itos);

  __ load_signed_byte(rax, at_bcp(1));

}

void TemplateTable::sipush() {

  transition(vtos, itos);

  __ load_unsigned_short(rax, at_bcp(1));

  __ bswapl(rax);

  __ sarl(rax, 16);

}

void TemplateTable::ldc(bool wide) {

  transition(vtos, vtos);

  Register rarg = NOT_LP64(rcx) LP64_ONLY(c_rarg1);

  Label call_ldc, notFloat, notClass, notInt, Done;

  if (wide) {

    __ get_unsigned_2_byte_index_at_bcp(rbx, 1);

  } else {

    __ load_unsigned_byte(rbx, at_bcp(1));

  }

  __ get_cpool_and_tags(rcx, rax);

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

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

  // get type

  __ movzbl(rdx, Address(rax, rbx, Address::times_1, tags_offset));

  // unresolved class - get the resolved class

  __ cmpl(rdx, JVM_CONSTANT_UnresolvedClass);

  __ jccb(Assembler::equal, call_ldc);

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

  // from the first resolution attempt

  __ cmpl(rdx, JVM_CONSTANT_UnresolvedClassInError);

  __ jccb(Assembler::equal, call_ldc);

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

  __ cmpl(rdx, JVM_CONSTANT_Class);

  __ jcc(Assembler::notEqual, notClass);

  __ bind(call_ldc);

  __ movl(rarg, wide);

  call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), rarg);

  __ push(atos);

  __ jmp(Done);

  __ bind(notClass);

  __ cmpl(rdx, JVM_CONSTANT_Float);

  __ jccb(Assembler::notEqual, notFloat);

  // ftos

  __ load_float(Address(rcx, rbx, Address::times_ptr, base_offset));

  __ push(ftos);

  __ jmp(Done);

  __ bind(notFloat);

  __ cmpl(rdx, JVM_CONSTANT_Integer);

  __ jccb(Assembler::notEqual, notInt);

  // itos

  __ movl(rax, Address(rcx, rbx, Address::times_ptr, base_offset));

  __ push(itos);

  __ jmp(Done);

  // assume the tag is for condy; if not, the VM runtime will tell us

  __ bind(notInt);

  condy_helper(Done);

  __ bind(Done);

}

// Fast path for caching oop constants.

void TemplateTable::fast_aldc(bool wide) {

  transition(vtos, atos);

  Register result = rax;

  Register tmp = rdx;

  Register rarg = NOT_LP64(rcx) LP64_ONLY(c_rarg1);

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

  __ testptr(result, result);