/*

 * 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 "jvm.h"

#include "asm/macroAssembler.inline.hpp"

#include "compiler/disassembler.hpp"

#include "gc/shared/collectedHeap.inline.hpp"

#include "gc/shared/barrierSet.hpp"

#include "gc/shared/barrierSetAssembler.hpp"

#include "interpreter/interpreter.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/accessDecorators.hpp"

#include "oops/klass.inline.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/flags/flagSetting.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/safepoint.hpp"

#include "runtime/safepointMechanism.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "utilities/align.hpp"

#include "utilities/macros.hpp"

#ifdef COMPILER2

#include "opto/intrinsicnode.hpp"

#endif

#ifdef PRODUCT

#define BLOCK_COMMENT(str) /* nothing */

#define STOP(error) stop(error)

#else

#define BLOCK_COMMENT(str) block_comment(str)

#define STOP(error) block_comment(error); stop(error)

#endif

// Convert the raw encoding form into the form expected by the

// constructor for Address.

Address Address::make_raw(int base, int index, int scale, int disp, relocInfo::relocType disp_reloc) {

  assert(scale == 0, "not supported");

  RelocationHolder rspec;

  if (disp_reloc != relocInfo::none) {

    rspec = Relocation::spec_simple(disp_reloc);

  }

  Register rindex = as_Register(index);

  if (rindex != G0) {

    Address madr(as_Register(base), rindex);

    madr._rspec = rspec;

    return madr;

  } else {

    Address madr(as_Register(base), disp);

    madr._rspec = rspec;

    return madr;

  }

}

Address Argument::address_in_frame() const {

  // Warning: In LP64 mode disp will occupy more than 10 bits, but

  //          op codes such as ld or ldx, only access disp() to get

  //          their simm13 argument.

  int disp = ((_number - Argument::n_register_parameters + frame::memory_parameter_word_sp_offset) * BytesPerWord) + STACK_BIAS;

  if (is_in())

    return Address(FP, disp); // In argument.

  else

    return Address(SP, disp); // Out argument.

}

static const char* argumentNames[][2] = {

  {"A0","P0"}, {"A1","P1"}, {"A2","P2"}, {"A3","P3"}, {"A4","P4"},

  {"A5","P5"}, {"A6","P6"}, {"A7","P7"}, {"A8","P8"}, {"A9","P9"},

  {"A(n>9)","P(n>9)"}

};

const char* Argument::name() const {

  int nofArgs = sizeof argumentNames / sizeof argumentNames[0];

  int num = number();

  if (num >= nofArgs)  num = nofArgs - 1;

  return argumentNames[num][is_in() ? 1 : 0];

}

#ifdef ASSERT

// On RISC, there's no benefit to verifying instruction boundaries.

bool AbstractAssembler::pd_check_instruction_mark() { return false; }

#endif

// Patch instruction inst at offset inst_pos to refer to dest_pos

// and return the resulting instruction.

// We should have pcs, not offsets, but since all is relative, it will work out

// OK.

int MacroAssembler::patched_branch(int dest_pos, int inst, int inst_pos) {

  int m; // mask for displacement field

  int v; // new value for displacement field

  const int word_aligned_ones = -4;

  switch (inv_op(inst)) {

  default: ShouldNotReachHere();

  case call_op:    m = wdisp(word_aligned_ones, 0, 30);  v = wdisp(dest_pos, inst_pos, 30); break;

  case branch_op:

    switch (inv_op2(inst)) {

      case fbp_op2:    m = wdisp(  word_aligned_ones, 0, 19);  v = wdisp(  dest_pos, inst_pos, 19); break;

      case bp_op2:     m = wdisp(  word_aligned_ones, 0, 19);  v = wdisp(  dest_pos, inst_pos, 19); break;

      case fb_op2:     m = wdisp(  word_aligned_ones, 0, 22);  v = wdisp(  dest_pos, inst_pos, 22); break;

      case br_op2:     m = wdisp(  word_aligned_ones, 0, 22);  v = wdisp(  dest_pos, inst_pos, 22); break;

      case bpr_op2: {

        if (is_cbcond(inst)) {

          m = wdisp10(word_aligned_ones, 0);

          v = wdisp10(dest_pos, inst_pos);

        } else {

          m = wdisp16(word_aligned_ones, 0);

          v = wdisp16(dest_pos, inst_pos);

        }

        break;

      }

      default: ShouldNotReachHere();

    }

  }

  return  inst & ~m  |  v;

}

// Return the offset of the branch destionation of instruction inst

// at offset pos.

// Should have pcs, but since all is relative, it works out.

int MacroAssembler::branch_destination(int inst, int pos) {

  int r;

  switch (inv_op(inst)) {

  default: ShouldNotReachHere();

  case call_op:        r = inv_wdisp(inst, pos, 30);  break;

  case branch_op:

    switch (inv_op2(inst)) {

      case fbp_op2:    r = inv_wdisp(  inst, pos, 19);  break;

      case bp_op2:     r = inv_wdisp(  inst, pos, 19);  break;

      case fb_op2:     r = inv_wdisp(  inst, pos, 22);  break;

      case br_op2:     r = inv_wdisp(  inst, pos, 22);  break;

      case bpr_op2: {

        if (is_cbcond(inst)) {

          r = inv_wdisp10(inst, pos);

        } else {

          r = inv_wdisp16(inst, pos);

        }

        break;

      }

      default: ShouldNotReachHere();

    }

  }

  return r;

}

void MacroAssembler::resolve_jobject(Register value, Register tmp) {

  Label done, not_weak;

  br_null(value, false, Assembler::pn, done); // Use NULL as-is.

  delayed()->andcc(value, JNIHandles::weak_tag_mask, G0); // Test for jweak

  brx(Assembler::zero, true, Assembler::pt, not_weak);

  delayed()->nop();

  access_load_at(T_OBJECT, IN_NATIVE | ON_PHANTOM_OOP_REF,

                 Address(value, -JNIHandles::weak_tag_value), value, tmp);

  verify_oop(value);

  br (Assembler::always, true, Assembler::pt, done);

  delayed()->nop();

  bind(not_weak);

  access_load_at(T_OBJECT, IN_NATIVE, Address(value, 0), value, tmp);

  verify_oop(value);

  bind(done);

}

void MacroAssembler::null_check(Register reg, int offset) {

  if (needs_explicit_null_check((intptr_t)offset)) {

    // provoke OS NULL exception if reg = NULL by

    // accessing M[reg] w/o changing any registers

    ld_ptr(reg, 0, G0);

  }

  else {

    // nothing to do, (later) access of M[reg + offset]

    // will provoke OS NULL exception if reg = NULL

  }

}

// Ring buffer jumps

void MacroAssembler::jmp2(Register r1, Register r2, const char* file, int line ) {

  assert_not_delayed();

  jmpl(r1, r2, G0);

}

void MacroAssembler::jmp(Register r1, int offset, const char* file, int line ) {

  assert_not_delayed();

  jmp(r1, offset);

}

// This code sequence is relocatable to any address, even on LP64.

void MacroAssembler::jumpl(const AddressLiteral& addrlit, Register temp, Register d, int offset, const char* file, int line) {

  assert_not_delayed();

  // Force fixed length sethi because NativeJump and NativeFarCall don't handle

  // variable length instruction streams.

  patchable_sethi(addrlit, temp);

  Address a(temp, addrlit.low10() + offset);  // Add the offset to the displacement.

  jmpl(a.base(), a.disp(), d);

}

void MacroAssembler::jump(const AddressLiteral& addrlit, Register temp, int offset, const char* file, int line) {

  jumpl(addrlit, temp, G0, offset, file, line);

}

// Conditional breakpoint (for assertion checks in assembly code)

void MacroAssembler::breakpoint_trap(Condition c, CC cc) {

  trap(c, cc, G0, ST_RESERVED_FOR_USER_0);

}

// We want to use ST_BREAKPOINT here, but the debugger is confused by it.

void MacroAssembler::breakpoint_trap() {

  trap(ST_RESERVED_FOR_USER_0);

}

void MacroAssembler::safepoint_poll(Label& slow_path, bool a, Register thread_reg, Register temp_reg) {

  if (SafepointMechanism::uses_thread_local_poll()) {

    ldx(Address(thread_reg, Thread::polling_page_offset()), temp_reg, 0);

    // Armed page has poll bit set.

    and3(temp_reg, SafepointMechanism::poll_bit(), temp_reg);

    br_notnull(temp_reg, a, Assembler::pn, slow_path);

  } else {

    AddressLiteral sync_state(SafepointSynchronize::address_of_state());

    load_contents(sync_state, temp_reg);

    cmp(temp_reg, SafepointSynchronize::_not_synchronized);

    br(Assembler::notEqual, a, Assembler::pn, slow_path);

  }

}

void MacroAssembler::enter() {

  Unimplemented();

}

void MacroAssembler::leave() {

  Unimplemented();

}

// Calls to C land

#ifdef ASSERT

// a hook for debugging

static Thread* reinitialize_thread() {

  return Thread::current();

}

#else

#define reinitialize_thread Thread::current

#endif

#ifdef ASSERT

address last_get_thread = NULL;

#endif

// call this when G2_thread is not known to be valid

void MacroAssembler::get_thread() {

  save_frame(0);                // to avoid clobbering O0

  mov(G1, L0);                  // avoid clobbering G1

  mov(G5_method, L1);           // avoid clobbering G5

  mov(G3, L2);                  // avoid clobbering G3 also

  mov(G4, L5);                  // avoid clobbering G4

#ifdef ASSERT

  AddressLiteral last_get_thread_addrlit(&last_get_thread);

  set(last_get_thread_addrlit, L3);

  rdpc(L4);

  inc(L4, 3 * BytesPerInstWord); // skip rdpc + inc + st_ptr to point L4 at call  st_ptr(L4, L3, 0);

#endif

  call(CAST_FROM_FN_PTR(address, reinitialize_thread), relocInfo::runtime_call_type);

  delayed()->nop();

  mov(L0, G1);

  mov(L1, G5_method);

  mov(L2, G3);

  mov(L5, G4);

  restore(O0, 0, G2_thread);

}

static Thread* verify_thread_subroutine(Thread* gthread_value) {

  Thread* correct_value = Thread::current();

  guarantee(gthread_value == correct_value, "G2_thread value must be the thread");

  return correct_value;

}

void MacroAssembler::verify_thread() {

  if (VerifyThread) {

    // NOTE: this chops off the heads of the 64-bit O registers.

    // make sure G2_thread contains the right value

    save_frame_and_mov(0, Lmethod, Lmethod);   // to avoid clobbering O0 (and propagate Lmethod)

    mov(G1, L1);                // avoid clobbering G1

    // G2 saved below

    mov(G3, L3);                // avoid clobbering G3

    mov(G4, L4);                // avoid clobbering G4

    mov(G5_method, L5);         // avoid clobbering G5_method

    call(CAST_FROM_FN_PTR(address,verify_thread_subroutine), relocInfo::runtime_call_type);

    delayed()->mov(G2_thread, O0);

    mov(L1, G1);                // Restore G1

    // G2 restored below

    mov(L3, G3);                // restore G3

    mov(L4, G4);                // restore G4

    mov(L5, G5_method);         // restore G5_method

    restore(O0, 0, G2_thread);

  }

}

void MacroAssembler::save_thread(const Register thread_cache) {

  verify_thread();

  if (thread_cache->is_valid()) {

    assert(thread_cache->is_local() || thread_cache->is_in(), "bad volatile");

    mov(G2_thread, thread_cache);

  }

  if (VerifyThread) {

    // smash G2_thread, as if the VM were about to anyway

    set(0x67676767, G2_thread);

  }

}

void MacroAssembler::restore_thread(const Register thread_cache) {

  if (thread_cache->is_valid()) {

    assert(thread_cache->is_local() || thread_cache->is_in(), "bad volatile");

    mov(thread_cache, G2_thread);

    verify_thread();

  } else {

    // do it the slow way

    get_thread();

  }

}

// %%% maybe get rid of [re]set_last_Java_frame

void MacroAssembler::set_last_Java_frame(Register last_java_sp, Register last_Java_pc) {

  assert_not_delayed();

  Address flags(G2_thread, JavaThread::frame_anchor_offset() +

                           JavaFrameAnchor::flags_offset());

  Address pc_addr(G2_thread, JavaThread::last_Java_pc_offset());

  // Always set last_Java_pc and flags first because once last_Java_sp is visible

  // has_last_Java_frame is true and users will look at the rest of the fields.

  // (Note: flags should always be zero before we get here so doesn't need to be set.)

#ifdef ASSERT

  // Verify that flags was zeroed on return to Java

  Label PcOk;

  save_frame(0);                // to avoid clobbering O0

  ld_ptr(pc_addr, L0);

  br_null_short(L0, Assembler::pt, PcOk);

  STOP("last_Java_pc not zeroed before leaving Java");

  bind(PcOk);

  // Verify that flags was zeroed on return to Java

  Label FlagsOk;

  ld(flags, L0);

  tst(L0);

  br(Assembler::zero, false, Assembler::pt, FlagsOk);

  delayed() -> restore();

  STOP("flags not zeroed before leaving Java");

  bind(FlagsOk);

#endif /* ASSERT */

  //

  // When returning from calling out from Java mode the frame anchor's last_Java_pc

  // will always be set to NULL. It is set here so that if we are doing a call to

  // native (not VM) that we capture the known pc and don't have to rely on the

  // native call having a standard frame linkage where we can find the pc.

  if (last_Java_pc->is_valid()) {

    st_ptr(last_Java_pc, pc_addr);

  }

#ifdef ASSERT

  // Make sure that we have an odd stack

  Label StackOk;

  andcc(last_java_sp, 0x01, G0);

  br(Assembler::notZero, false, Assembler::pt, StackOk);

  delayed()->nop();

  STOP("Stack Not Biased in set_last_Java_frame");

  bind(StackOk);

#endif // ASSERT

  assert( last_java_sp != G4_scratch, "bad register usage in set_last_Java_frame");

  add( last_java_sp, STACK_BIAS, G4_scratch );

  st_ptr(G4_scratch, G2_thread, JavaThread::last_Java_sp_offset());

}

void MacroAssembler::reset_last_Java_frame(void) {

  assert_not_delayed();

  Address sp_addr(G2_thread, JavaThread::last_Java_sp_offset());

  Address pc_addr(G2_thread, JavaThread::frame_anchor_offset() + JavaFrameAnchor::last_Java_pc_offset());

  Address flags  (G2_thread, JavaThread::frame_anchor_offset() + JavaFrameAnchor::flags_offset());

#ifdef ASSERT

  // check that it WAS previously set

    save_frame_and_mov(0, Lmethod, Lmethod);     // Propagate Lmethod to helper frame

    ld_ptr(sp_addr, L0);

    tst(L0);

    breakpoint_trap(Assembler::zero, Assembler::ptr_cc);

    restore();

#endif // ASSERT

  st_ptr(G0, sp_addr);

  // Always return last_Java_pc to zero

  st_ptr(G0, pc_addr);

  // Always null flags after return to Java

  st(G0, flags);

}

void MacroAssembler::call_VM_base(

  Register        oop_result,

  Register        thread_cache,

  Register        last_java_sp,

  address         entry_point,

  int             number_of_arguments,

  bool            check_exceptions)

{

  assert_not_delayed();

  // determine last_java_sp register

  if (!last_java_sp->is_valid()) {

    last_java_sp = SP;

  }

  // debugging support

  assert(number_of_arguments >= 0   , "cannot have negative number of arguments");

  // 64-bit last_java_sp is biased!

  set_last_Java_frame(last_java_sp, noreg);

  if (VerifyThread)  mov(G2_thread, O0); // about to be smashed; pass early

  save_thread(thread_cache);

  // do the call

  call(entry_point, relocInfo::runtime_call_type);

  if (!VerifyThread)

    delayed()->mov(G2_thread, O0);  // pass thread as first argument

  else

    delayed()->nop();             // (thread already passed)

  restore_thread(thread_cache);

  reset_last_Java_frame();

  // check for pending exceptions. use Gtemp as scratch register.

  if (check_exceptions) {

    check_and_forward_exception(Gtemp);

  }

#ifdef ASSERT

  set(badHeapWordVal, G3);

  set(badHeapWordVal, G4);

  set(badHeapWordVal, G5);

#endif

  // get oop result if there is one and reset the value in the thread

  if (oop_result->is_valid()) {

    get_vm_result(oop_result);

  }

}

void MacroAssembler::check_and_forward_exception(Register scratch_reg)

{

  Label L;

  check_and_handle_popframe(scratch_reg);

  check_and_handle_earlyret(scratch_reg);

  Address exception_addr(G2_thread, Thread::pending_exception_offset());

  ld_ptr(exception_addr, scratch_reg);

  br_null_short(scratch_reg, pt, L);

  // we use O7 linkage so that forward_exception_entry has the issuing PC

  call(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type);

  delayed()->nop();

  bind(L);

}

void MacroAssembler::check_and_handle_popframe(Register scratch_reg) {

}

void MacroAssembler::check_and_handle_earlyret(Register scratch_reg) {

}

void MacroAssembler::call_VM(Register oop_result, address entry_point, int number_of_arguments, bool check_exceptions) {

  call_VM_base(oop_result, noreg, noreg, entry_point, number_of_arguments, check_exceptions);

}

void MacroAssembler::call_VM(Register oop_result, address entry_point, Register arg_1, bool check_exceptions) {

  // O0 is reserved for the thread

  mov(arg_1, O1);

  call_VM(oop_result, entry_point, 1, check_exceptions);

}

void MacroAssembler::call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2, bool check_exceptions) {

  // O0 is reserved for the thread

  mov(arg_1, O1);

  mov(arg_2, O2); assert(arg_2 != O1, "smashed argument");

  call_VM(oop_result, entry_point, 2, check_exceptions);

}

void MacroAssembler::call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2, Register arg_3, bool check_exceptions) {