/*

 * Copyright (c) 1997, 2011, 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/assembler.hpp"

#include "assembler_sparc.inline.hpp"

#include "interpreter/interpreter.hpp"

#include "nativeInst_sparc.hpp"

#include "oops/instanceOop.hpp"

#include "oops/methodOop.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 "utilities/top.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "thread_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "thread_solaris.inline.hpp"

#endif

#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

static address handle_unsafe_access() {

  JavaThread* thread = JavaThread::current();

  address pc  = thread->saved_exception_pc();

  address npc = thread->saved_exception_npc();

  // pc is the instruction which we must emulate

  // doing a no-op is fine:  return garbage from the load

  // request an async exception

  thread->set_pending_unsafe_access_error();

  // return address of next instruction to execute

  return npc;

}

class StubGenerator: public StubCodeGenerator {

 private:

#ifdef PRODUCT

#define inc_counter_np(a,b,c) (0)

#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(t, false, Assembler::pt, L);

      __ delayed()->nop();

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

      __ tst(cnt);

      __ br(Assembler::zero, false, Assembler::pn, 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

#ifdef _LP64

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

#endif

    __ 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(false, exit);

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

      __ BIND(is_float);

      __ ba(false, exit);

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

      __ BIND(is_double);

      __ ba(false, exit);

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

      __ BIND(is_long);

#ifdef _LP64

      __ ba(false, exit);

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

#else

#if defined(COMPILER2)

  // All return values are where we want them, except for Longs.  C2 returns

  // longs in G1 in the 32-bit build whereas the interpreter wants them in O0/O1.

  // Since the interpreter will return longs in G1 and O0/O1 in the 32bit

  // build we simply always use G1.

  // Note: I tried to make c2 return longs in O0/O1 and G1 so we wouldn't have to

  // do this here. Unfortunately if we did a rethrow we'd see an machepilog node

  // first which would move g1 -> O0/O1 and destroy the exception we were throwing.

      __ ba(false, exit);

      __ delayed()->stx(G1, addr, G0);  // store entire long

#else

      __ st(O1, addr, BytesPerInt);

      __ ba(false, exit);

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

#endif /* COMPILER2 */

#endif /* _LP64 */

     }

     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(Gtemp, false, Assembler::pt, L);

      __ delayed()->nop();

      __ 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(Oexception, false, Assembler::pt, L);

      __ delayed()->nop();

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

  }

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

  // 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->

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

    if (restore_saved_exception_pc) {

      __ ld_ptr(G2_thread, JavaThread::saved_exception_pc_offset(), I7);

      __ sub(I7, frame::pc_return_offset, I7);

    }

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

    // 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(scratch_reg, false, Assembler::pt, L);

    __ delayed()->nop();

    __ 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.