/*

 * Copyright (c) 1997, 2015, 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 "compiler/disassembler.hpp"

#include "gc/shared/cardTableModRefBS.hpp"

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

#include "interpreter/interpreter.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/klass.inline.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "utilities/macros.hpp"

#if INCLUDE_ALL_GCS

#include "gc/g1/g1CollectedHeap.inline.hpp"

#include "gc/g1/g1SATBCardTableModRefBS.hpp"

#include "gc/g1/heapRegion.hpp"

#endif // INCLUDE_ALL_GCS

#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::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

#ifndef PRODUCT

void MacroAssembler::ret(  bool trace )   { if (trace) {

                                                    mov(I7, O7); // traceable register

                                                    JMP(O7, 2 * BytesPerInstWord);

                                                  } else {

                                                    jmpl( I7, 2 * BytesPerInstWord, G0 );

                                                  }

                                                }

void MacroAssembler::retl( bool trace )  { if (trace) JMP(O7, 2 * BytesPerInstWord);

                                                 else jmpl( O7, 2 * BytesPerInstWord, G0 ); }

#endif /* PRODUCT */

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

  assert_not_delayed();

  // This can only be traceable if r1 & r2 are visible after a window save

  if (TraceJumps) {

#ifndef PRODUCT

    save_frame(0);

    verify_thread();

    ld(G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()), O0);

    add(G2_thread, in_bytes(JavaThread::jmp_ring_offset()), O1);

    sll(O0, exact_log2(4*sizeof(intptr_t)), O2);

    add(O2, O1, O1);

    add(r1->after_save(), r2->after_save(), O2);

    set((intptr_t)file, O3);

    set(line, O4);

    Label L;

    // get nearby pc, store jmp target

    call(L, relocInfo::none);  // No relocation for call to pc+0x8

    delayed()->st(O2, O1, 0);

    bind(L);

    // store nearby pc

    st(O7, O1, sizeof(intptr_t));

    // store file

    st(O3, O1, 2*sizeof(intptr_t));

    // store line

    st(O4, O1, 3*sizeof(intptr_t));

    add(O0, 1, O0);

    and3(O0, JavaThread::jump_ring_buffer_size  - 1, O0);

    st(O0, G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()));

    restore();

#endif /* PRODUCT */

  }

  jmpl(r1, r2, G0);

}

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

  assert_not_delayed();

  // This can only be traceable if r1 is visible after a window save

  if (TraceJumps) {

#ifndef PRODUCT

    save_frame(0);

    verify_thread();

    ld(G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()), O0);

    add(G2_thread, in_bytes(JavaThread::jmp_ring_offset()), O1);

    sll(O0, exact_log2(4*sizeof(intptr_t)), O2);

    add(O2, O1, O1);

    add(r1->after_save(), offset, O2);

    set((intptr_t)file, O3);

    set(line, O4);

    Label L;

    // get nearby pc, store jmp target

    call(L, relocInfo::none);  // No relocation for call to pc+0x8

    delayed()->st(O2, O1, 0);

    bind(L);

    // store nearby pc

    st(O7, O1, sizeof(intptr_t));

    // store file

    st(O3, O1, 2*sizeof(intptr_t));

    // store line

    st(O4, O1, 3*sizeof(intptr_t));

    add(O0, 1, O0);

    and3(O0, JavaThread::jump_ring_buffer_size  - 1, O0);

    st(O0, G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()));

    restore();

#endif /* PRODUCT */

  }

  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.

  if (TraceJumps) {

#ifndef PRODUCT

    // Must do the add here so relocation can find the remainder of the

    // value to be relocated.

    add(a.base(), a.disp(), a.base(), addrlit.rspec(offset));

    save_frame(0);

    verify_thread();

    ld(G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()), O0);

    add(G2_thread, in_bytes(JavaThread::jmp_ring_offset()), O1);

    sll(O0, exact_log2(4*sizeof(intptr_t)), O2);

    add(O2, O1, O1);

    set((intptr_t)file, O3);

    set(line, O4);

    Label L;

    // get nearby pc, store jmp target

    call(L, relocInfo::none);  // No relocation for call to pc+0x8

    delayed()->st(a.base()->after_save(), O1, 0);

    bind(L);

    // store nearby pc

    st(O7, O1, sizeof(intptr_t));

    // store file

    st(O3, O1, 2*sizeof(intptr_t));

    // store line

    st(O4, O1, 3*sizeof(intptr_t));

    add(O0, 1, O0);

    and3(O0, JavaThread::jump_ring_buffer_size  - 1, O0);

    st(O0, G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()));

    restore();

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

#else

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

#endif /* PRODUCT */

  } else {

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

}

// Write serialization page so VM thread can do a pseudo remote membar

// We use the current thread pointer to calculate a thread specific

// offset to write to within the page. This minimizes bus traffic

// due to cache line collision.

void MacroAssembler::serialize_memory(Register thread, Register tmp1, Register tmp2) {

  srl(thread, os::get_serialize_page_shift_count(), tmp2);

  if (Assembler::is_simm13(os::vm_page_size())) {

    and3(tmp2, (os::vm_page_size() - sizeof(int)), tmp2);

  }

  else {

    set((os::vm_page_size() - sizeof(int)), tmp1);

    and3(tmp2, tmp1, tmp2);

  }

  set(os::get_memory_serialize_page(), tmp1);

  st(G0, tmp1, tmp2);

}

void MacroAssembler::enter() {

  Unimplemented();

}

void MacroAssembler::leave() {

  Unimplemented();

}

// Calls to C land

#ifdef ASSERT

// a hook for debugging

static Thread* reinitialize_thread() {

  return ThreadLocalStorage::thread();

}

#else

#define reinitialize_thread ThreadLocalStorage::thread

#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 = ThreadLocalStorage::thread();

  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.

#ifdef CC_INTERP

    save_frame(0);

#else

    // make sure G2_thread contains the right value

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

    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

#endif /* CC_INTERP */

#if defined(COMPILER2) && !defined(_LP64)

    // Save & restore possible 64-bit Long arguments in G-regs

    srlx(G1,32,L0);

    srlx(G4,32,L6);

#endif

    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

#if defined(COMPILER2) && !defined(_LP64)

    // Save & restore possible 64-bit Long arguments in G-regs

    sllx(L0,32,G2);             // Move old high G1 bits high in G2

    srl(G1, 0,G1);              // Clear current high G1 bits

    or3 (G1,G2,G1);             // Recover 64-bit G1

    sllx(L6,32,G2);             // Move old high G4 bits high in G2

    srl(G4, 0,G4);              // Clear current high G4 bits

    or3 (G4,G2,G4);             // Recover 64-bit G4

#endif

    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 _LP64

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

#else

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

#endif // _LP64

}

void MacroAssembler::reset_last_Java_frame(void) {

  assert_not_delayed();