/*

 * 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.inline.hpp"

#include "gc/shared/cardTable.hpp"

#include "gc/shared/cardTableModRefBS.hpp"

#include "interpreter/interpreter.hpp"

#include "nativeInst_sparc.hpp"

#include "oops/instanceOop.hpp"

#include "oops/method.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubCodeGenerator.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/thread.inline.hpp"

#ifdef COMPILER2

#include "opto/runtime.hpp"

#endif

// Declaration and definition of StubGenerator (no .hpp file).

// For a more detailed description of the stub routine structure

// see the comment in stubRoutines.hpp.

#define __ _masm->

#ifdef PRODUCT

#define BLOCK_COMMENT(str) /* nothing */

#else

#define BLOCK_COMMENT(str) __ block_comment(str)

#endif

#define BIND(label) bind(label); BLOCK_COMMENT(#label ":")

// Note:  The register L7 is used as L7_thread_cache, and may not be used

//        any other way within this module.

static const Register& Lstub_temp = L2;

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

// Stub Code definitions

class StubGenerator: public StubCodeGenerator {

 private:

#ifdef PRODUCT

#define inc_counter_np(a,b,c)

#else

#define inc_counter_np(counter, t1, t2) \

  BLOCK_COMMENT("inc_counter " #counter); \

  __ inc_counter(&counter, t1, t2);

#endif

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

  // Call stubs are used to call Java from C

  address generate_call_stub(address& return_pc) {

    StubCodeMark mark(this, "StubRoutines", "call_stub");

    address start = __ pc();

    // Incoming arguments:

    //

    // o0         : call wrapper address

    // o1         : result (address)

    // o2         : result type

    // o3         : method

    // o4         : (interpreter) entry point

    // o5         : parameters (address)

    // [sp + 0x5c]: parameter size (in words)

    // [sp + 0x60]: thread

    //

    // +---------------+ <--- sp + 0

    // |               |

    // . reg save area .

    // |               |

    // +---------------+ <--- sp + 0x40

    // |               |

    // . extra 7 slots .

    // |               |

    // +---------------+ <--- sp + 0x5c

    // |  param. size  |

    // +---------------+ <--- sp + 0x60

    // |    thread     |

    // +---------------+

    // |               |

    // note: if the link argument position changes, adjust

    //       the code in frame::entry_frame_call_wrapper()

    const Argument link           = Argument(0, false); // used only for GC

    const Argument result         = Argument(1, false);

    const Argument result_type    = Argument(2, false);

    const Argument method         = Argument(3, false);

    const Argument entry_point    = Argument(4, false);

    const Argument parameters     = Argument(5, false);

    const Argument parameter_size = Argument(6, false);

    const Argument thread         = Argument(7, false);

    // setup thread register

    __ ld_ptr(thread.as_address(), G2_thread);

    __ reinit_heapbase();

#ifdef ASSERT

    // make sure we have no pending exceptions

    { const Register t = G3_scratch;

      Label L;

      __ ld_ptr(G2_thread, in_bytes(Thread::pending_exception_offset()), t);

      __ br_null_short(t, Assembler::pt, L);

      __ stop("StubRoutines::call_stub: entered with pending exception");

      __ bind(L);

    }

#endif

    // create activation frame & allocate space for parameters

    { const Register t = G3_scratch;

      __ ld_ptr(parameter_size.as_address(), t);                // get parameter size (in words)

      __ add(t, frame::memory_parameter_word_sp_offset, t);     // add space for save area (in words)

      __ round_to(t, WordsPerLong);                             // make sure it is multiple of 2 (in words)

      __ sll(t, Interpreter::logStackElementSize, t);           // compute number of bytes

      __ neg(t);                                                // negate so it can be used with save

      __ save(SP, t, SP);                                       // setup new frame

    }

    // +---------------+ <--- sp + 0

    // |               |

    // . reg save area .

    // |               |

    // +---------------+ <--- sp + 0x40

    // |               |

    // . extra 7 slots .

    // |               |

    // +---------------+ <--- sp + 0x5c

    // |  empty slot   |      (only if parameter size is even)

    // +---------------+

    // |               |

    // .  parameters   .

    // |               |

    // +---------------+ <--- fp + 0

    // |               |

    // . reg save area .

    // |               |

    // +---------------+ <--- fp + 0x40

    // |               |

    // . extra 7 slots .

    // |               |

    // +---------------+ <--- fp + 0x5c

    // |  param. size  |

    // +---------------+ <--- fp + 0x60

    // |    thread     |

    // +---------------+

    // |               |

    // pass parameters if any

    BLOCK_COMMENT("pass parameters if any");

    { const Register src = parameters.as_in().as_register();

      const Register dst = Lentry_args;

      const Register tmp = G3_scratch;

      const Register cnt = G4_scratch;

      // test if any parameters & setup of Lentry_args

      Label exit;

      __ ld_ptr(parameter_size.as_in().as_address(), cnt);      // parameter counter

      __ add( FP, STACK_BIAS, dst );

      __ cmp_zero_and_br(Assembler::zero, cnt, exit);

      __ delayed()->sub(dst, BytesPerWord, dst);                 // setup Lentry_args

      // copy parameters if any

      Label loop;

      __ BIND(loop);

      // Store parameter value

      __ ld_ptr(src, 0, tmp);

      __ add(src, BytesPerWord, src);

      __ st_ptr(tmp, dst, 0);

      __ deccc(cnt);

      __ br(Assembler::greater, false, Assembler::pt, loop);

      __ delayed()->sub(dst, Interpreter::stackElementSize, dst);

      // done

      __ BIND(exit);

    }

    // setup parameters, method & call Java function

#ifdef ASSERT

    // layout_activation_impl checks it's notion of saved SP against

    // this register, so if this changes update it as well.

    const Register saved_SP = Lscratch;

    __ mov(SP, saved_SP);                               // keep track of SP before call

#endif

    // setup parameters

    const Register t = G3_scratch;

    __ ld_ptr(parameter_size.as_in().as_address(), t); // get parameter size (in words)

    __ sll(t, Interpreter::logStackElementSize, t);    // compute number of bytes

    __ sub(FP, t, Gargs);                              // setup parameter pointer

    __ add( Gargs, STACK_BIAS, Gargs );                // Account for LP64 stack bias

    __ mov(SP, O5_savedSP);

    // do the call

    //

    // the following register must be setup:

    //

    // G2_thread

    // G5_method

    // Gargs

    BLOCK_COMMENT("call Java function");

    __ jmpl(entry_point.as_in().as_register(), G0, O7);

    __ delayed()->mov(method.as_in().as_register(), G5_method);   // setup method

    BLOCK_COMMENT("call_stub_return_address:");

    return_pc = __ pc();

    // The callee, if it wasn't interpreted, can return with SP changed so

    // we can no longer assert of change of SP.

    // store result depending on type

    // (everything that is not T_OBJECT, T_LONG, T_FLOAT, or T_DOUBLE

    //  is treated as T_INT)

    { const Register addr = result     .as_in().as_register();

      const Register type = result_type.as_in().as_register();

      Label is_long, is_float, is_double, is_object, exit;

      __            cmp(type, T_OBJECT);  __ br(Assembler::equal, false, Assembler::pn, is_object);

      __ delayed()->cmp(type, T_FLOAT);   __ br(Assembler::equal, false, Assembler::pn, is_float);

      __ delayed()->cmp(type, T_DOUBLE);  __ br(Assembler::equal, false, Assembler::pn, is_double);

      __ delayed()->cmp(type, T_LONG);    __ br(Assembler::equal, false, Assembler::pn, is_long);

      __ delayed()->nop();

      // store int result

      __ st(O0, addr, G0);

      __ BIND(exit);

      __ ret();

      __ delayed()->restore();

      __ BIND(is_object);

      __ ba(exit);

      __ delayed()->st_ptr(O0, addr, G0);

      __ BIND(is_float);

      __ ba(exit);

      __ delayed()->stf(FloatRegisterImpl::S, F0, addr, G0);

      __ BIND(is_double);

      __ ba(exit);

      __ delayed()->stf(FloatRegisterImpl::D, F0, addr, G0);

      __ BIND(is_long);

      __ ba(exit);

      __ delayed()->st_long(O0, addr, G0);      // store entire long

     }

     return start;

  }

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

  // Return point for a Java call if there's an exception thrown in Java code.

  // The exception is caught and transformed into a pending exception stored in

  // JavaThread that can be tested from within the VM.

  //

  // Oexception: exception oop

  address generate_catch_exception() {

    StubCodeMark mark(this, "StubRoutines", "catch_exception");

    address start = __ pc();

    // verify that thread corresponds

    __ verify_thread();

    const Register& temp_reg = Gtemp;

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

    Address exception_file_offset_addr(G2_thread, Thread::exception_file_offset   ());

    Address exception_line_offset_addr(G2_thread, Thread::exception_line_offset   ());

    // set pending exception

    __ verify_oop(Oexception);

    __ st_ptr(Oexception, pending_exception_addr);

    __ set((intptr_t)__FILE__, temp_reg);

    __ st_ptr(temp_reg, exception_file_offset_addr);

    __ set((intptr_t)__LINE__, temp_reg);

    __ st(temp_reg, exception_line_offset_addr);

    // complete return to VM

    assert(StubRoutines::_call_stub_return_address != NULL, "must have been generated before");

    AddressLiteral stub_ret(StubRoutines::_call_stub_return_address);

    __ jump_to(stub_ret, temp_reg);

    __ delayed()->nop();

    return start;

  }

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

  // Continuation point for runtime calls returning with a pending exception

  // The pending exception check happened in the runtime or native call stub

  // The pending exception in Thread is converted into a Java-level exception

  //

  // Contract with Java-level exception handler: O0 = exception

  //                                             O1 = throwing pc

  address generate_forward_exception() {

    StubCodeMark mark(this, "StubRoutines", "forward_exception");

    address start = __ pc();

    // Upon entry, O7 has the return address returning into Java

    // (interpreted or compiled) code; i.e. the return address

    // becomes the throwing pc.

    const Register& handler_reg = Gtemp;

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

#ifdef ASSERT

    // make sure that this code is only executed if there is a pending exception

    { Label L;

      __ ld_ptr(exception_addr, Gtemp);

      __ br_notnull_short(Gtemp, Assembler::pt, L);

      __ stop("StubRoutines::forward exception: no pending exception (1)");

      __ bind(L);

    }

#endif

    // compute exception handler into handler_reg

    __ get_thread();

    __ ld_ptr(exception_addr, Oexception);

    __ verify_oop(Oexception);

    __ save_frame(0);             // compensates for compiler weakness

    __ add(O7->after_save(), frame::pc_return_offset, Lscratch); // save the issuing PC

    BLOCK_COMMENT("call exception_handler_for_return_address");

    __ call_VM_leaf(L7_thread_cache, CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), G2_thread, Lscratch);

    __ mov(O0, handler_reg);

    __ restore();                 // compensates for compiler weakness

    __ ld_ptr(exception_addr, Oexception);

    __ add(O7, frame::pc_return_offset, Oissuing_pc); // save the issuing PC

#ifdef ASSERT

    // make sure exception is set

    { Label L;

      __ br_notnull_short(Oexception, Assembler::pt, L);

      __ stop("StubRoutines::forward exception: no pending exception (2)");

      __ bind(L);

    }

#endif

    // jump to exception handler

    __ jmp(handler_reg, 0);

    // clear pending exception

    __ delayed()->st_ptr(G0, exception_addr);

    return start;

  }

  // Safefetch stubs.

  void generate_safefetch(const char* name, int size, address* entry,

                          address* fault_pc, address* continuation_pc) {

    // safefetch signatures:

    //   int      SafeFetch32(int*      adr, int      errValue);

    //   intptr_t SafeFetchN (intptr_t* adr, intptr_t errValue);

    //

    // arguments:

    //   o0 = adr

    //   o1 = errValue

    //

    // result:

    //   o0  = *adr or errValue

    StubCodeMark mark(this, "StubRoutines", name);

    // Entry point, pc or function descriptor.

    __ align(CodeEntryAlignment);

    *entry = __ pc();

    __ mov(O0, G1);  // g1 = o0

    __ mov(O1, O0);  // o0 = o1

    // Load *adr into c_rarg1, may fault.

    *fault_pc = __ pc();

    switch (size) {

      case 4:

        // int32_t

        __ ldsw(G1, 0, O0);  // o0 = [g1]

        break;

      case 8:

        // int64_t

        __ ldx(G1, 0, O0);   // o0 = [g1]

        break;

      default:

        ShouldNotReachHere();

    }

    // return errValue or *adr

    *continuation_pc = __ pc();

    // By convention with the trap handler we ensure there is a non-CTI

    // instruction in the trap shadow.

    __ nop();

    __ retl();

    __ delayed()->nop();

  }

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

  // Continuation point for throwing of implicit exceptions that are not handled in

  // the current activation. Fabricates an exception oop and initiates normal

  // exception dispatching in this frame. Only callee-saved registers are preserved

  // (through the normal register window / RegisterMap handling).

  // If the compiler needs all registers to be preserved between the fault

  // point and the exception handler then it must assume responsibility for that in

  // AbstractCompiler::continuation_for_implicit_null_exception or

  // continuation_for_implicit_division_by_zero_exception. All other implicit

  // exceptions (e.g., NullPointerException or AbstractMethodError on entry) are

  // either at call sites or otherwise assume that stack unwinding will be initiated,

  // so caller saved registers were assumed volatile in the compiler.

  // Note that we generate only this stub into a RuntimeStub, because it needs to be

  // properly traversed and ignored during GC, so we change the meaning of the "__"

  // macro within this method.

#undef __

#define __ masm->

  address generate_throw_exception(const char* name, address runtime_entry,

                                   Register arg1 = noreg, Register arg2 = noreg) {

#ifdef ASSERT

    int insts_size = VerifyThread ? 1 * K : 600;

#else

    int insts_size = VerifyThread ? 1 * K : 256;

#endif /* ASSERT */

    int locs_size  = 32;

    CodeBuffer      code(name, insts_size, locs_size);

    MacroAssembler* masm = new MacroAssembler(&code);

    __ verify_thread();

    // This is an inlined and slightly modified version of call_VM

    // which has the ability to fetch the return PC out of thread-local storage

    __ assert_not_delayed();

    // Note that we always push a frame because on the SPARC

    // architecture, for all of our implicit exception kinds at call

    // sites, the implicit exception is taken before the callee frame

    // is pushed.

    __ save_frame(0);

    int frame_complete = __ offset();

    // Note that we always have a runtime stub frame on the top of stack by this point

    Register last_java_sp = SP;

    // 64-bit last_java_sp is biased!

    __ set_last_Java_frame(last_java_sp, G0);

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

    __ save_thread(noreg);

    if (arg1 != noreg) {

      assert(arg2 != O1, "clobbered");

      __ mov(arg1, O1);

    }

    if (arg2 != noreg) {

      __ mov(arg2, O2);

    }

    // do the call

    BLOCK_COMMENT("call runtime_entry");

    __ call(runtime_entry, relocInfo::runtime_call_type);

    if (!VerifyThread)

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

    else

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

    __ restore_thread(noreg);

    __ reset_last_Java_frame();

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

#ifdef ASSERT

    Label L;

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

    Register scratch_reg = Gtemp;

    __ ld_ptr(exception_addr, scratch_reg);

    __ br_notnull_short(scratch_reg, Assembler::pt, L);

    __ should_not_reach_here();

    __ bind(L);

#endif // ASSERT

    BLOCK_COMMENT("call forward_exception_entry");

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

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

    __ delayed()->restore();

    RuntimeStub* stub = RuntimeStub::new_runtime_stub(name, &code, frame_complete, masm->total_frame_size_in_bytes(0), NULL, false);

    return stub->entry_point();

  }

#undef __

#define __ _masm->

  // Generate a routine that sets all the registers so we

  // can tell if the stop routine prints them correctly.