/*

 * Copyright (c) 1997, 2012, 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.

 *

 */

#ifndef CPU_SPARC_VM_MACROASSEMBLER_SPARC_INLINE_HPP

#define CPU_SPARC_VM_MACROASSEMBLER_SPARC_INLINE_HPP

#include "asm/assembler.inline.hpp"

#include "asm/macroAssembler.hpp"

#include "asm/codeBuffer.hpp"

#include "code/codeCache.hpp"

inline bool Address::is_simm13(int offset) { return Assembler::is_simm13(disp() + offset); }

inline int AddressLiteral::low10() const {

  return Assembler::low10(value());

}

inline void MacroAssembler::pd_patch_instruction(address branch, address target) {

  jint& stub_inst = *(jint*) branch;

  stub_inst = patched_branch(target - branch, stub_inst, 0);

}

// Use the right loads/stores for the platform

inline void MacroAssembler::ld_ptr( Register s1, Register s2, Register d ) {

#ifdef _LP64

  Assembler::ldx(s1, s2, d);

#else

             ld( s1, s2, d);

#endif

}

inline void MacroAssembler::ld_ptr( Register s1, int simm13a, Register d ) {

#ifdef _LP64

  Assembler::ldx(s1, simm13a, d);

#else

             ld( s1, simm13a, d);

#endif

}

#ifdef ASSERT

// ByteSize is only a class when ASSERT is defined, otherwise it's an int.

inline void MacroAssembler::ld_ptr( Register s1, ByteSize simm13a, Register d ) {

  ld_ptr(s1, in_bytes(simm13a), d);

}

#endif

inline void MacroAssembler::ld_ptr( Register s1, RegisterOrConstant s2, Register d ) {

#ifdef _LP64

  ldx(s1, s2, d);

#else

  ld( s1, s2, d);

#endif

}

inline void MacroAssembler::ld_ptr(const Address& a, Register d, int offset) {

#ifdef _LP64

  ldx(a, d, offset);

#else

  ld( a, d, offset);

#endif

}

inline void MacroAssembler::st_ptr( Register d, Register s1, Register s2 ) {

#ifdef _LP64

  Assembler::stx(d, s1, s2);

#else

             st( d, s1, s2);

#endif

}

inline void MacroAssembler::st_ptr( Register d, Register s1, int simm13a ) {

#ifdef _LP64

  Assembler::stx(d, s1, simm13a);

#else

             st( d, s1, simm13a);

#endif

}

#ifdef ASSERT

// ByteSize is only a class when ASSERT is defined, otherwise it's an int.

inline void MacroAssembler::st_ptr( Register d, Register s1, ByteSize simm13a ) {

  st_ptr(d, s1, in_bytes(simm13a));

}

#endif

inline void MacroAssembler::st_ptr( Register d, Register s1, RegisterOrConstant s2 ) {

#ifdef _LP64

  stx(d, s1, s2);

#else

  st( d, s1, s2);

#endif

}

inline void MacroAssembler::st_ptr(Register d, const Address& a, int offset) {

#ifdef _LP64

  stx(d, a, offset);

#else

  st( d, a, offset);

#endif

}

// Use the right loads/stores for the platform

inline void MacroAssembler::ld_long( Register s1, Register s2, Register d ) {

#ifdef _LP64

  Assembler::ldx(s1, s2, d);

#else

  Assembler::ldd(s1, s2, d);

#endif

}

inline void MacroAssembler::ld_long( Register s1, int simm13a, Register d ) {

#ifdef _LP64

  Assembler::ldx(s1, simm13a, d);

#else

  Assembler::ldd(s1, simm13a, d);

#endif

}

inline void MacroAssembler::ld_long( Register s1, RegisterOrConstant s2, Register d ) {

#ifdef _LP64

  ldx(s1, s2, d);

#else

  ldd(s1, s2, d);

#endif

}

inline void MacroAssembler::ld_long(const Address& a, Register d, int offset) {

#ifdef _LP64

  ldx(a, d, offset);

#else

  ldd(a, d, offset);

#endif

}

inline void MacroAssembler::st_long( Register d, Register s1, Register s2 ) {

#ifdef _LP64

  Assembler::stx(d, s1, s2);

#else

  Assembler::std(d, s1, s2);

#endif

}

inline void MacroAssembler::st_long( Register d, Register s1, int simm13a ) {

#ifdef _LP64

  Assembler::stx(d, s1, simm13a);

#else

  Assembler::std(d, s1, simm13a);

#endif

}

inline void MacroAssembler::st_long( Register d, Register s1, RegisterOrConstant s2 ) {

#ifdef _LP64

  stx(d, s1, s2);

#else

  std(d, s1, s2);

#endif

}

inline void MacroAssembler::st_long( Register d, const Address& a, int offset ) {

#ifdef _LP64

  stx(d, a, offset);

#else

  std(d, a, offset);

#endif

}

// Functions for isolating 64 bit shifts for LP64

inline void MacroAssembler::sll_ptr( Register s1, Register s2, Register d ) {

#ifdef _LP64

  Assembler::sllx(s1, s2, d);

#else

  Assembler::sll( s1, s2, d);

#endif

}

inline void MacroAssembler::sll_ptr( Register s1, int imm6a,   Register d ) {

#ifdef _LP64

  Assembler::sllx(s1, imm6a, d);

#else

  Assembler::sll( s1, imm6a, d);

#endif

}

inline void MacroAssembler::srl_ptr( Register s1, Register s2, Register d ) {

#ifdef _LP64

  Assembler::srlx(s1, s2, d);

#else

  Assembler::srl( s1, s2, d);

#endif

}

inline void MacroAssembler::srl_ptr( Register s1, int imm6a,   Register d ) {

#ifdef _LP64

  Assembler::srlx(s1, imm6a, d);

#else

  Assembler::srl( s1, imm6a, d);

#endif

}

inline void MacroAssembler::sll_ptr( Register s1, RegisterOrConstant s2, Register d ) {

  if (s2.is_register())  sll_ptr(s1, s2.as_register(), d);

  else                   sll_ptr(s1, s2.as_constant(), d);

}

// Use the right branch for the platform

inline void MacroAssembler::br( Condition c, bool a, Predict p, address d, relocInfo::relocType rt ) {

  if (VM_Version::v9_instructions_work())

    Assembler::bp(c, a, icc, p, d, rt);

  else

    Assembler::br(c, a, d, rt);

}

inline void MacroAssembler::br( Condition c, bool a, Predict p, Label& L ) {

  br(c, a, p, target(L));

}

// Branch that tests either xcc or icc depending on the

// architecture compiled (LP64 or not)

inline void MacroAssembler::brx( Condition c, bool a, Predict p, address d, relocInfo::relocType rt ) {

#ifdef _LP64

    Assembler::bp(c, a, xcc, p, d, rt);

#else

    MacroAssembler::br(c, a, p, d, rt);

#endif

}

inline void MacroAssembler::brx( Condition c, bool a, Predict p, Label& L ) {

  brx(c, a, p, target(L));

}

inline void MacroAssembler::ba( Label& L ) {

  br(always, false, pt, L);

}

// Warning: V9 only functions

inline void MacroAssembler::bp( Condition c, bool a, CC cc, Predict p, address d, relocInfo::relocType rt ) {

  Assembler::bp(c, a, cc, p, d, rt);

}

inline void MacroAssembler::bp( Condition c, bool a, CC cc, Predict p, Label& L ) {

  Assembler::bp(c, a, cc, p, L);

}

inline void MacroAssembler::fb( Condition c, bool a, Predict p, address d, relocInfo::relocType rt ) {

  if (VM_Version::v9_instructions_work())

    fbp(c, a, fcc0, p, d, rt);

  else

    Assembler::fb(c, a, d, rt);

}

inline void MacroAssembler::fb( Condition c, bool a, Predict p, Label& L ) {

  fb(c, a, p, target(L));

}

inline void MacroAssembler::fbp( Condition c, bool a, CC cc, Predict p, address d, relocInfo::relocType rt ) {

  Assembler::fbp(c, a, cc, p, d, rt);

}

inline void MacroAssembler::fbp( Condition c, bool a, CC cc, Predict p, Label& L ) {

  Assembler::fbp(c, a, cc, p, L);

}

inline void MacroAssembler::jmp( Register s1, Register s2 ) { jmpl( s1, s2, G0 ); }

inline void MacroAssembler::jmp( Register s1, int simm13a, RelocationHolder const& rspec ) { jmpl( s1, simm13a, G0, rspec); }

inline bool MacroAssembler::is_far_target(address d) {

  if (ForceUnreachable) {

    // References outside the code cache should be treated as far

    return d < CodeCache::low_bound() || d > CodeCache::high_bound();

  }

  return !is_in_wdisp30_range(d, CodeCache::low_bound()) || !is_in_wdisp30_range(d, CodeCache::high_bound());

}

// Call with a check to see if we need to deal with the added

// expense of relocation and if we overflow the displacement

// of the quick call instruction.

inline void MacroAssembler::call( address d, relocInfo::relocType rt ) {

#ifdef _LP64

  intptr_t disp;

  // NULL is ok because it will be relocated later.

  // Must change NULL to a reachable address in order to

  // pass asserts here and in wdisp.

  if ( d == NULL )

    d = pc();

  // Is this address within range of the call instruction?

  // If not, use the expensive instruction sequence

  if (is_far_target(d)) {

    relocate(rt);

    AddressLiteral dest(d);

    jumpl_to(dest, O7, O7);

  } else {

    Assembler::call(d, rt);

  }

#else

  Assembler::call( d, rt );

#endif

}

inline void MacroAssembler::call( Label& L,   relocInfo::relocType rt ) {

  MacroAssembler::call( target(L), rt);

}

inline void MacroAssembler::callr( Register s1, Register s2 ) { jmpl( s1, s2, O7 ); }

inline void MacroAssembler::callr( Register s1, int simm13a, RelocationHolder const& rspec ) { jmpl( s1, simm13a, O7, rspec); }

// prefetch instruction

inline void MacroAssembler::iprefetch( address d, relocInfo::relocType rt ) {

  if (VM_Version::v9_instructions_work())

    Assembler::bp( never, true, xcc, pt, d, rt );

}

inline void MacroAssembler::iprefetch( Label& L) { iprefetch( target(L) ); }

// clobbers o7 on V8!!

// returns delta from gotten pc to addr after

inline int MacroAssembler::get_pc( Register d ) {

  int x = offset();

  if (VM_Version::v9_instructions_work())

    rdpc(d);

  else {

    Label lbl;

    Assembler::call(lbl, relocInfo::none);  // No relocation as this is call to pc+0x8

    if (d == O7)  delayed()->nop();

    else          delayed()->mov(O7, d);

    bind(lbl);

  }

  return offset() - x;

}

// Note:  All MacroAssembler::set_foo functions are defined out-of-line.

// Loads the current PC of the following instruction as an immediate value in

// 2 instructions.  All PCs in the CodeCache are within 2 Gig of each other.

inline intptr_t MacroAssembler::load_pc_address( Register reg, int bytes_to_skip ) {

  intptr_t thepc = (intptr_t)pc() + 2*BytesPerInstWord + bytes_to_skip;

#ifdef _LP64

  Unimplemented();

#else

  Assembler::sethi(   thepc & ~0x3ff, reg, internal_word_Relocation::spec((address)thepc));

             add(reg, thepc &  0x3ff, reg, internal_word_Relocation::spec((address)thepc));

#endif

  return thepc;

}

inline void MacroAssembler::load_contents(const AddressLiteral& addrlit, Register d, int offset) {

  assert_not_delayed();

  if (ForceUnreachable) {

    patchable_sethi(addrlit, d);

  } else {

    sethi(addrlit, d);

  }

  ld(d, addrlit.low10() + offset, d);

}

inline void MacroAssembler::load_bool_contents(const AddressLiteral& addrlit, Register d, int offset) {

  assert_not_delayed();

  if (ForceUnreachable) {

    patchable_sethi(addrlit, d);

  } else {

    sethi(addrlit, d);

  }

  ldub(d, addrlit.low10() + offset, d);

}

inline void MacroAssembler::load_ptr_contents(const AddressLiteral& addrlit, Register d, int offset) {

  assert_not_delayed();

  if (ForceUnreachable) {

    patchable_sethi(addrlit, d);

  } else {

    sethi(addrlit, d);

  }

  ld_ptr(d, addrlit.low10() + offset, d);

}

inline void MacroAssembler::store_contents(Register s, const AddressLiteral& addrlit, Register temp, int offset) {

  assert_not_delayed();

  if (ForceUnreachable) {

    patchable_sethi(addrlit, temp);

  } else {

    sethi(addrlit, temp);

  }

  st(s, temp, addrlit.low10() + offset);

}

inline void MacroAssembler::store_ptr_contents(Register s, const AddressLiteral& addrlit, Register temp, int offset) {

  assert_not_delayed();

  if (ForceUnreachable) {

    patchable_sethi(addrlit, temp);

  } else {

    sethi(addrlit, temp);

  }

  st_ptr(s, temp, addrlit.low10() + offset);

}

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

inline void MacroAssembler::jumpl_to(const AddressLiteral& addrlit, Register temp, Register d, int offset) {

  assert_not_delayed();

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

  // variable length instruction streams.

  patchable_sethi(addrlit, temp);

  jmpl(temp, addrlit.low10() + offset, d);

}

inline void MacroAssembler::jump_to(const AddressLiteral& addrlit, Register temp, int offset) {

  jumpl_to(addrlit, temp, G0, offset);

}

inline void MacroAssembler::jump_indirect_to(Address& a, Register temp,

                                             int ld_offset, int jmp_offset) {

  assert_not_delayed();

  //sethi(al);                   // sethi is caller responsibility for this one

  ld_ptr(a, temp, ld_offset);

  jmp(temp, jmp_offset);

}

inline void MacroAssembler::set_metadata(Metadata* obj, Register d) {

  set_metadata(allocate_metadata_address(obj), d);

}

inline void MacroAssembler::set_metadata_constant(Metadata* obj, Register d) {

  set_metadata(constant_metadata_address(obj), d);

}

inline void MacroAssembler::set_metadata(const AddressLiteral& obj_addr, Register d) {

  assert(obj_addr.rspec().type() == relocInfo::metadata_type, "must be a metadata reloc");

  set(obj_addr, d);

}

inline void MacroAssembler::set_oop(jobject obj, Register d) {

  set_oop(allocate_oop_address(obj), d);

}

inline void MacroAssembler::set_oop_constant(jobject obj, Register d) {

  set_oop(constant_oop_address(obj), d);

}

inline void MacroAssembler::set_oop(const AddressLiteral& obj_addr, Register d) {

  assert(obj_addr.rspec().type() == relocInfo::oop_type, "must be an oop reloc");

  set(obj_addr, d);

}

inline void MacroAssembler::load_argument( Argument& a, Register  d ) {

  if (a.is_register())

    mov(a.as_register(), d);

  else

    ld (a.as_address(),  d);

}

inline void MacroAssembler::store_argument( Register s, Argument& a ) {

  if (a.is_register())

    mov(s, a.as_register());

  else

    st_ptr (s, a.as_address());         // ABI says everything is right justified.

}

inline void MacroAssembler::store_ptr_argument( Register s, Argument& a ) {

  if (a.is_register())

    mov(s, a.as_register());

  else

    st_ptr (s, a.as_address());

}

#ifdef _LP64

inline void MacroAssembler::store_float_argument( FloatRegister s, Argument& a ) {

  if (a.is_float_register())

// V9 ABI has F1, F3, F5 are used to pass instead of O0, O1, O2

    fmov(FloatRegisterImpl::S, s, a.as_float_register() );

  else

    // Floats are stored in the high half of the stack entry

    // The low half is undefined per the ABI.

    stf(FloatRegisterImpl::S, s, a.as_address(), sizeof(jfloat));

}

inline void MacroAssembler::store_double_argument( FloatRegister s, Argument& a ) {

  if (a.is_float_register())

// V9 ABI has D0, D2, D4 are used to pass instead of O0, O1, O2

    fmov(FloatRegisterImpl::D, s, a.as_double_register() );

  else

    stf(FloatRegisterImpl::D, s, a.as_address());

}

inline void MacroAssembler::store_long_argument( Register s, Argument& a ) {

  if (a.is_register())

    mov(s, a.as_register());