/*

 * Copyright (c) 2003, 2017, 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 "code/debugInfoRec.hpp"

#include "code/icBuffer.hpp"

#include "code/vtableStubs.hpp"

#include "interpreter/interpreter.hpp"

#include "logging/log.hpp"

#include "memory/resourceArea.hpp"

#include "oops/compiledICHolder.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/vframeArray.hpp"

#include "utilities/align.hpp"

#include "vmreg_sparc.inline.hpp"

#ifdef COMPILER1

#include "c1/c1_Runtime1.hpp"

#endif

#ifdef COMPILER2

#include "opto/runtime.hpp"

#endif

#ifdef SHARK

#include "compiler/compileBroker.hpp"

#include "shark/sharkCompiler.hpp"

#endif

#if INCLUDE_JVMCI

#include "jvmci/jvmciJavaClasses.hpp"

#endif

#define __ masm->

class RegisterSaver {

  // Used for saving volatile registers. This is Gregs, Fregs, I/L/O.

  // The Oregs are problematic. In the 32bit build the compiler can

  // have O registers live with 64 bit quantities. A window save will

  // cut the heads off of the registers. We have to do a very extensive

  // stack dance to save and restore these properly.

  // Note that the Oregs problem only exists if we block at either a polling

  // page exception a compiled code safepoint that was not originally a call

  // or deoptimize following one of these kinds of safepoints.

  // Lots of registers to save.  For all builds, a window save will preserve

  // the %i and %l registers.  For the 32-bit longs-in-two entries and 64-bit

  // builds a window-save will preserve the %o registers.  In the LION build

  // we need to save the 64-bit %o registers which requires we save them

  // before the window-save (as then they become %i registers and get their

  // heads chopped off on interrupt).  We have to save some %g registers here

  // as well.

  enum {

    // This frame's save area.  Includes extra space for the native call:

    // vararg's layout space and the like.  Briefly holds the caller's

    // register save area.

    call_args_area = frame::register_save_words_sp_offset +

                     frame::memory_parameter_word_sp_offset*wordSize,

    // Make sure save locations are always 8 byte aligned.

    // can't use align_up because it doesn't produce compile time constant

    start_of_extra_save_area = ((call_args_area + 7) & ~7),

    g1_offset = start_of_extra_save_area, // g-regs needing saving

    g3_offset = g1_offset+8,

    g4_offset = g3_offset+8,

    g5_offset = g4_offset+8,

    o0_offset = g5_offset+8,

    o1_offset = o0_offset+8,

    o2_offset = o1_offset+8,

    o3_offset = o2_offset+8,

    o4_offset = o3_offset+8,

    o5_offset = o4_offset+8,

    start_of_flags_save_area = o5_offset+8,

    ccr_offset = start_of_flags_save_area,

    fsr_offset = ccr_offset + 8,

    d00_offset = fsr_offset+8,  // Start of float save area

    register_save_size = d00_offset+8*32

  };

  public:

  static int Oexception_offset() { return o0_offset; };

  static int G3_offset() { return g3_offset; };

  static int G5_offset() { return g5_offset; };

  static OopMap* save_live_registers(MacroAssembler* masm, int additional_frame_words, int* total_frame_words);

  static void restore_live_registers(MacroAssembler* masm);

  // During deoptimization only the result register need to be restored

  // all the other values have already been extracted.

  static void restore_result_registers(MacroAssembler* masm);

};

OopMap* RegisterSaver::save_live_registers(MacroAssembler* masm, int additional_frame_words, int* total_frame_words) {

  // Record volatile registers as callee-save values in an OopMap so their save locations will be

  // propagated to the caller frame's RegisterMap during StackFrameStream construction (needed for

  // deoptimization; see compiledVFrame::create_stack_value).  The caller's I, L and O registers

  // are saved in register windows - I's and L's in the caller's frame and O's in the stub frame

  // (as the stub's I's) when the runtime routine called by the stub creates its frame.

  int i;

  // Always make the frame size 16 byte aligned.

  int frame_size = align_up(additional_frame_words + register_save_size, 16);

  // OopMap frame size is in c2 stack slots (sizeof(jint)) not bytes or words

  int frame_size_in_slots = frame_size / sizeof(jint);

  // CodeBlob frame size is in words.

  *total_frame_words = frame_size / wordSize;

  // OopMap* map = new OopMap(*total_frame_words, 0);

  OopMap* map = new OopMap(frame_size_in_slots, 0);

  __ save(SP, -frame_size, SP);

  int debug_offset = 0;

  // Save the G's

  __ stx(G1, SP, g1_offset+STACK_BIAS);

  map->set_callee_saved(VMRegImpl::stack2reg((g1_offset + debug_offset)>>2), G1->as_VMReg());

  __ stx(G3, SP, g3_offset+STACK_BIAS);

  map->set_callee_saved(VMRegImpl::stack2reg((g3_offset + debug_offset)>>2), G3->as_VMReg());

  __ stx(G4, SP, g4_offset+STACK_BIAS);

  map->set_callee_saved(VMRegImpl::stack2reg((g4_offset + debug_offset)>>2), G4->as_VMReg());

  __ stx(G5, SP, g5_offset+STACK_BIAS);

  map->set_callee_saved(VMRegImpl::stack2reg((g5_offset + debug_offset)>>2), G5->as_VMReg());

  // This is really a waste but we'll keep things as they were for now

  if (true) {

  }

  // Save the flags

  __ rdccr( G5 );

  __ stx(G5, SP, ccr_offset+STACK_BIAS);

  __ stxfsr(SP, fsr_offset+STACK_BIAS);

  // Save all the FP registers: 32 doubles (32 floats correspond to the 2 halves of the first 16 doubles)

  int offset = d00_offset;

  for( int i=0; i<FloatRegisterImpl::number_of_registers; i+=2 ) {

    FloatRegister f = as_FloatRegister(i);

    __ stf(FloatRegisterImpl::D,  f, SP, offset+STACK_BIAS);

    // Record as callee saved both halves of double registers (2 float registers).

    map->set_callee_saved(VMRegImpl::stack2reg(offset>>2), f->as_VMReg());

    map->set_callee_saved(VMRegImpl::stack2reg((offset + sizeof(float))>>2), f->as_VMReg()->next());

    offset += sizeof(double);

  }

  // And we're done.

  return map;

}

// Pop the current frame and restore all the registers that we

// saved.

void RegisterSaver::restore_live_registers(MacroAssembler* masm) {

  // Restore all the FP registers

  for( int i=0; i<FloatRegisterImpl::number_of_registers; i+=2 ) {

    __ ldf(FloatRegisterImpl::D, SP, d00_offset+i*sizeof(float)+STACK_BIAS, as_FloatRegister(i));

  }

  __ ldx(SP, ccr_offset+STACK_BIAS, G1);

  __ wrccr (G1) ;

  // Restore the G's

  // Note that G2 (AKA GThread) must be saved and restored separately.

  // TODO-FIXME: save and restore some of the other ASRs, viz., %asi and %gsr.

  __ ldx(SP, g1_offset+STACK_BIAS, G1);

  __ ldx(SP, g3_offset+STACK_BIAS, G3);

  __ ldx(SP, g4_offset+STACK_BIAS, G4);

  __ ldx(SP, g5_offset+STACK_BIAS, G5);

  // Restore flags

  __ ldxfsr(SP, fsr_offset+STACK_BIAS);

  __ restore();

}

// Pop the current frame and restore the registers that might be holding

// a result.

void RegisterSaver::restore_result_registers(MacroAssembler* masm) {

  __ ldf(FloatRegisterImpl::D, SP, d00_offset+STACK_BIAS, as_FloatRegister(0));

  __ restore();

}

// Is vector's size (in bytes) bigger than a size saved by default?

// 8 bytes FP registers are saved by default on SPARC.

bool SharedRuntime::is_wide_vector(int size) {

  // Note, MaxVectorSize == 8 on SPARC.

  assert(size <= 8, "%d bytes vectors are not supported", size);

  return size > 8;

}

size_t SharedRuntime::trampoline_size() {

  return 40;

}

void SharedRuntime::generate_trampoline(MacroAssembler *masm, address destination) {

  __ set((intptr_t)destination, G3_scratch);

  __ JMP(G3_scratch, 0);

  __ delayed()->nop();

}

// The java_calling_convention describes stack locations as ideal slots on

// a frame with no abi restrictions. Since we must observe abi restrictions

// (like the placement of the register window) the slots must be biased by

// the following value.

static int reg2offset(VMReg r) {

  return (r->reg2stack() + SharedRuntime::out_preserve_stack_slots()) * VMRegImpl::stack_slot_size;

}

static VMRegPair reg64_to_VMRegPair(Register r) {

  VMRegPair ret;

  if (wordSize == 8) {

    ret.set2(r->as_VMReg());

  } else {

    ret.set_pair(r->successor()->as_VMReg(), r->as_VMReg());

  }

  return ret;

}

// ---------------------------------------------------------------------------

// Read the array of BasicTypes from a signature, and compute where the

// arguments should go.  Values in the VMRegPair regs array refer to 4-byte (VMRegImpl::stack_slot_size)

// quantities.  Values less than VMRegImpl::stack0 are registers, those above

// refer to 4-byte stack slots.  All stack slots are based off of the window

// top.  VMRegImpl::stack0 refers to the first slot past the 16-word window,

// and VMRegImpl::stack0+1 refers to the memory word 4-byes higher.  Register

// values 0-63 (up to RegisterImpl::number_of_registers) are the 64-bit

// integer registers.  Values 64-95 are the (32-bit only) float registers.

// Each 32-bit quantity is given its own number, so the integer registers

// (in either 32- or 64-bit builds) use 2 numbers.  For example, there is

// an O0-low and an O0-high.  Essentially, all int register numbers are doubled.

// Register results are passed in O0-O5, for outgoing call arguments.  To

// convert to incoming arguments, convert all O's to I's.  The regs array

// refer to the low and hi 32-bit words of 64-bit registers or stack slots.

// If the regs[].second() field is set to VMRegImpl::Bad(), it means it's unused (a

// 32-bit value was passed).  If both are VMRegImpl::Bad(), it means no value was

// passed (used as a placeholder for the other half of longs and doubles in

// the 64-bit build).  regs[].second() is either VMRegImpl::Bad() or regs[].second() is

// regs[].first()+1 (regs[].first() may be misaligned in the C calling convention).

// Sparc never passes a value in regs[].second() but not regs[].first() (regs[].first()

// == VMRegImpl::Bad() && regs[].second() != VMRegImpl::Bad()) nor unrelated values in the

// same VMRegPair.

// Note: the INPUTS in sig_bt are in units of Java argument words, which are

// either 32-bit or 64-bit depending on the build.  The OUTPUTS are in 32-bit

// units regardless of build.

// ---------------------------------------------------------------------------

// The compiled Java calling convention.  The Java convention always passes

// 64-bit values in adjacent aligned locations (either registers or stack),

// floats in float registers and doubles in aligned float pairs.  There is

// no backing varargs store for values in registers.

// In the 32-bit build, longs are passed on the stack (cannot be

// passed in I's, because longs in I's get their heads chopped off at

// interrupt).

int SharedRuntime::java_calling_convention(const BasicType *sig_bt,

                                           VMRegPair *regs,

                                           int total_args_passed,

                                           int is_outgoing) {

  assert(F31->as_VMReg()->is_reg(), "overlapping stack/register numbers");

  const int int_reg_max = SPARC_ARGS_IN_REGS_NUM;

  const int flt_reg_max = 8;

  int int_reg = 0;

  int flt_reg = 0;

  int slot = 0;

  for (int i = 0; i < total_args_passed; i++) {

    switch (sig_bt[i]) {

    case T_INT:

    case T_SHORT:

    case T_CHAR:

    case T_BYTE:

    case T_BOOLEAN:

      if (int_reg < int_reg_max) {

        Register r = is_outgoing ? as_oRegister(int_reg++) : as_iRegister(int_reg++);

        regs[i].set1(r->as_VMReg());

      } else {

        regs[i].set1(VMRegImpl::stack2reg(slot++));

      }

      break;

    case T_LONG:

      assert((i + 1) < total_args_passed && sig_bt[i+1] == T_VOID, "expecting VOID in other half");

      // fall-through

    case T_OBJECT:

    case T_ARRAY:

    case T_ADDRESS: // Used, e.g., in slow-path locking for the lock's stack address

      if (int_reg < int_reg_max) {

        Register r = is_outgoing ? as_oRegister(int_reg++) : as_iRegister(int_reg++);

        regs[i].set2(r->as_VMReg());

      } else {

        slot = align_up(slot, 2);  // align

        regs[i].set2(VMRegImpl::stack2reg(slot));

        slot += 2;

      }

      break;

    case T_FLOAT:

      if (flt_reg < flt_reg_max) {

        FloatRegister r = as_FloatRegister(flt_reg++);

        regs[i].set1(r->as_VMReg());

      } else {

        regs[i].set1(VMRegImpl::stack2reg(slot++));

      }

      break;

    case T_DOUBLE:

      assert((i + 1) < total_args_passed && sig_bt[i+1] == T_VOID, "expecting half");

      if (align_up(flt_reg, 2) + 1 < flt_reg_max) {

        flt_reg = align_up(flt_reg, 2);  // align

        FloatRegister r = as_FloatRegister(flt_reg);

        regs[i].set2(r->as_VMReg());

        flt_reg += 2;

      } else {

        slot = align_up(slot, 2);  // align

        regs[i].set2(VMRegImpl::stack2reg(slot));

        slot += 2;

      }

      break;

    case T_VOID:

      regs[i].set_bad();   // Halves of longs & doubles

      break;

    default:

      fatal("unknown basic type %d", sig_bt[i]);

      break;

    }

  }

  // retun the amount of stack space these arguments will need.

  return slot;

}

// Helper class mostly to avoid passing masm everywhere, and handle

// store displacement overflow logic.

class AdapterGenerator {

  MacroAssembler *masm;

  Register Rdisp;

  void set_Rdisp(Register r)  { Rdisp = r; }

  void patch_callers_callsite();

  // base+st_off points to top of argument

  int arg_offset(const int st_off) { return st_off; }

  int next_arg_offset(const int st_off) {

    return st_off - Interpreter::stackElementSize;

  }

  // Argument slot values may be loaded first into a register because

  // they might not fit into displacement.

  RegisterOrConstant arg_slot(const int st_off);

  RegisterOrConstant next_arg_slot(const int st_off);

  // Stores long into offset pointed to by base

  void store_c2i_long(Register r, Register base,

                      const int st_off, bool is_stack);

  void store_c2i_object(Register r, Register base,

                        const int st_off);

  void store_c2i_int(Register r, Register base,

                     const int st_off);

  void store_c2i_double(VMReg r_2,

                        VMReg r_1, Register base, const int st_off);

  void store_c2i_float(FloatRegister f, Register base,

                       const int st_off);

 public:

  void gen_c2i_adapter(int total_args_passed,

                              // VMReg max_arg,

                              int comp_args_on_stack, // VMRegStackSlots

                              const BasicType *sig_bt,

                              const VMRegPair *regs,

                              Label& skip_fixup);

  void gen_i2c_adapter(int total_args_passed,

                       // VMReg max_arg,

                       int comp_args_on_stack, // VMRegStackSlots

                       const BasicType *sig_bt,

                       const VMRegPair *regs);

  AdapterGenerator(MacroAssembler *_masm) : masm(_masm) {}

};

// Patch the callers callsite with entry to compiled code if it exists.

void AdapterGenerator::patch_callers_callsite() {

  Label L;

  __ ld_ptr(G5_method, in_bytes(Method::code_offset()), G3_scratch);

  __ br_null(G3_scratch, false, Assembler::pt, L);

  __ delayed()->nop();

  // Call into the VM to patch the caller, then jump to compiled callee

  __ save_frame(4);     // Args in compiled layout; do not blow them

  // Must save all the live Gregs the list is:

  // G1: 1st Long arg (32bit build)

  // G2: global allocated to TLS

  // G3: used in inline cache check (scratch)

  // G4: 2nd Long arg (32bit build);

  // G5: used in inline cache check (Method*)

  // The longs must go to the stack by hand since in the 32 bit build they can be trashed by window ops.

  // mov(s,d)

  __ mov(G1, L1);

  __ mov(G4, L4);

  __ mov(G5_method, L5);

  __ mov(G5_method, O0);         // VM needs target method

  __ mov(I7, O1);                // VM needs caller's callsite

  // Must be a leaf call...

  // can be very far once the blob has been relocated

  AddressLiteral dest(CAST_FROM_FN_PTR(address, SharedRuntime::fixup_callers_callsite));

  __ relocate(relocInfo::runtime_call_type);

  __ jumpl_to(dest, O7, O7);

  __ delayed()->mov(G2_thread, L7_thread_cache);

  __ mov(L7_thread_cache, G2_thread);

  __ mov(L1, G1);

  __ mov(L4, G4);

  __ mov(L5, G5_method);

  __ restore();      // Restore args

  __ bind(L);

}

RegisterOrConstant AdapterGenerator::arg_slot(const int st_off) {

  RegisterOrConstant roc(arg_offset(st_off));

  return __ ensure_simm13_or_reg(roc, Rdisp);

}

RegisterOrConstant AdapterGenerator::next_arg_slot(const int st_off) {

  RegisterOrConstant roc(next_arg_offset(st_off));

  return __ ensure_simm13_or_reg(roc, Rdisp);

}

// Stores long into offset pointed to by base

void AdapterGenerator::store_c2i_long(Register r, Register base,

                                      const int st_off, bool is_stack) {

  // In V9, longs are given 2 64-bit slots in the interpreter, but the

  // data is passed in only 1 slot.

  __ stx(r, base, next_arg_slot(st_off));

}

void AdapterGenerator::store_c2i_object(Register r, Register base,

                      const int st_off) {

  __ st_ptr (r, base, arg_slot(st_off));

}

void AdapterGenerator::store_c2i_int(Register r, Register base,

                   const int st_off) {

  __ st (r, base, arg_slot(st_off));

}

// Stores into offset pointed to by base

void AdapterGenerator::store_c2i_double(VMReg r_2,

                      VMReg r_1, Register base, const int st_off) {

  // In V9, doubles are given 2 64-bit slots in the interpreter, but the

  // data is passed in only 1 slot.

  __ stf(FloatRegisterImpl::D, r_1->as_FloatRegister(), base, next_arg_slot(st_off));

}

void AdapterGenerator::store_c2i_float(FloatRegister f, Register base,

                                       const int st_off) {

  __ stf(FloatRegisterImpl::S, f, base, arg_slot(st_off));

}

void AdapterGenerator::gen_c2i_adapter(

                            int total_args_passed,

                            // VMReg max_arg,

                            int comp_args_on_stack, // VMRegStackSlots

                            const BasicType *sig_bt,

                            const VMRegPair *regs,

                            Label& L_skip_fixup) {

  // Before we get into the guts of the C2I adapter, see if we should be here

  // at all.  We've come from compiled code and are attempting to jump to the

  // interpreter, which means the caller made a static call to get here

  // (vcalls always get a compiled target if there is one).  Check for a

  // compiled target.  If there is one, we need to patch the caller's call.