/*

 * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.

 * Copyright (c) 2012, 2019, SAP SE. 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/barrierSet.hpp"

#include "gc/shared/barrierSetAssembler.hpp"

#include "interpreter/interpreter.hpp"

#include "nativeInst_ppc.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"

#include "utilities/align.hpp"

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

#if defined(ABI_ELFv2)

#define STUB_ENTRY(name) StubRoutines::name()

#else

#define STUB_ENTRY(name) ((FunctionDescriptor*)StubRoutines::name())->entry()

#endif

class StubGenerator: public StubCodeGenerator {

 private:

  // Call stubs are used to call Java from C

  //

  // Arguments:

  //

  //   R3  - call wrapper address     : address

  //   R4  - result                   : intptr_t*

  //   R5  - result type              : BasicType

  //   R6  - method                   : Method

  //   R7  - frame mgr entry point    : address

  //   R8  - parameter block          : intptr_t*

  //   R9  - parameter count in words : int

  //   R10 - thread                   : Thread*

  //

  address generate_call_stub(address& return_address) {

    // Setup a new c frame, copy java arguments, call frame manager or

    // native_entry, and process result.

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

    address start = __ function_entry();

    // some sanity checks

    assert((sizeof(frame::abi_minframe) % 16) == 0,           "unaligned");

    assert((sizeof(frame::abi_reg_args) % 16) == 0,           "unaligned");

    assert((sizeof(frame::spill_nonvolatiles) % 16) == 0,     "unaligned");

    assert((sizeof(frame::parent_ijava_frame_abi) % 16) == 0, "unaligned");

    assert((sizeof(frame::entry_frame_locals) % 16) == 0,     "unaligned");

    Register r_arg_call_wrapper_addr        = R3;

    Register r_arg_result_addr              = R4;

    Register r_arg_result_type              = R5;

    Register r_arg_method                   = R6;

    Register r_arg_entry                    = R7;

    Register r_arg_thread                   = R10;

    Register r_temp                         = R24;

    Register r_top_of_arguments_addr        = R25;

    Register r_entryframe_fp                = R26;

    {

      // Stack on entry to call_stub:

      //

      //      F1      [C_FRAME]

      //              ...

      Register r_arg_argument_addr          = R8;

      Register r_arg_argument_count         = R9;

      Register r_frame_alignment_in_bytes   = R27;

      Register r_argument_addr              = R28;

      Register r_argumentcopy_addr          = R29;

      Register r_argument_size_in_bytes     = R30;

      Register r_frame_size                 = R23;

      Label arguments_copied;

      // Save LR/CR to caller's C_FRAME.

      __ save_LR_CR(R0);

      // Zero extend arg_argument_count.

      __ clrldi(r_arg_argument_count, r_arg_argument_count, 32);

      // Save non-volatiles GPRs to ENTRY_FRAME (not yet pushed, but it's safe).

      __ save_nonvolatile_gprs(R1_SP, _spill_nonvolatiles_neg(r14));

      // Keep copy of our frame pointer (caller's SP).

      __ mr(r_entryframe_fp, R1_SP);

      BLOCK_COMMENT("Push ENTRY_FRAME including arguments");

      // Push ENTRY_FRAME including arguments:

      //

      //      F0      [TOP_IJAVA_FRAME_ABI]

      //              alignment (optional)

      //              [outgoing Java arguments]

      //              [ENTRY_FRAME_LOCALS]

      //      F1      [C_FRAME]

      //              ...

      // calculate frame size

      // unaligned size of arguments

      __ sldi(r_argument_size_in_bytes,

                  r_arg_argument_count, Interpreter::logStackElementSize);

      // arguments alignment (max 1 slot)

      // FIXME: use round_to() here

      __ andi_(r_frame_alignment_in_bytes, r_arg_argument_count, 1);

      __ sldi(r_frame_alignment_in_bytes,

              r_frame_alignment_in_bytes, Interpreter::logStackElementSize);

      // size = unaligned size of arguments + top abi's size

      __ addi(r_frame_size, r_argument_size_in_bytes,

              frame::top_ijava_frame_abi_size);

      // size += arguments alignment

      __ add(r_frame_size,

             r_frame_size, r_frame_alignment_in_bytes);

      // size += size of call_stub locals

      __ addi(r_frame_size,

              r_frame_size, frame::entry_frame_locals_size);

      // push ENTRY_FRAME

      __ push_frame(r_frame_size, r_temp);

      // initialize call_stub locals (step 1)

      __ std(r_arg_call_wrapper_addr,

             _entry_frame_locals_neg(call_wrapper_address), r_entryframe_fp);

      __ std(r_arg_result_addr,

             _entry_frame_locals_neg(result_address), r_entryframe_fp);

      __ std(r_arg_result_type,

             _entry_frame_locals_neg(result_type), r_entryframe_fp);

      // we will save arguments_tos_address later

      BLOCK_COMMENT("Copy Java arguments");

      // copy Java arguments

      // Calculate top_of_arguments_addr which will be R17_tos (not prepushed) later.

      // FIXME: why not simply use SP+frame::top_ijava_frame_size?

      __ addi(r_top_of_arguments_addr,

              R1_SP, frame::top_ijava_frame_abi_size);

      __ add(r_top_of_arguments_addr,

             r_top_of_arguments_addr, r_frame_alignment_in_bytes);

      // any arguments to copy?

      __ cmpdi(CCR0, r_arg_argument_count, 0);

      __ beq(CCR0, arguments_copied);

      // prepare loop and copy arguments in reverse order

      {

        // init CTR with arg_argument_count

        __ mtctr(r_arg_argument_count);

        // let r_argumentcopy_addr point to last outgoing Java arguments P

        __ mr(r_argumentcopy_addr, r_top_of_arguments_addr);

        // let r_argument_addr point to last incoming java argument

        __ add(r_argument_addr,

                   r_arg_argument_addr, r_argument_size_in_bytes);

        __ addi(r_argument_addr, r_argument_addr, -BytesPerWord);

        // now loop while CTR > 0 and copy arguments

        {

          Label next_argument;

          __ bind(next_argument);

          __ ld(r_temp, 0, r_argument_addr);

          // argument_addr--;

          __ addi(r_argument_addr, r_argument_addr, -BytesPerWord);

          __ std(r_temp, 0, r_argumentcopy_addr);

          // argumentcopy_addr++;

          __ addi(r_argumentcopy_addr, r_argumentcopy_addr, BytesPerWord);

          __ bdnz(next_argument);

        }

      }

      // Arguments copied, continue.

      __ bind(arguments_copied);

    }

    {

      BLOCK_COMMENT("Call frame manager or native entry.");

      // Call frame manager or native entry.

      Register r_new_arg_entry = R14;

      assert_different_registers(r_new_arg_entry, r_top_of_arguments_addr,

                                 r_arg_method, r_arg_thread);

      __ mr(r_new_arg_entry, r_arg_entry);

      // Register state on entry to frame manager / native entry:

      //

      //   tos         -  intptr_t*    sender tos (prepushed) Lesp = (SP) + copied_arguments_offset - 8

      //   R19_method  -  Method

      //   R16_thread  -  JavaThread*

      // Tos must point to last argument - element_size.

      const Register tos = R15_esp;

      __ addi(tos, r_top_of_arguments_addr, -Interpreter::stackElementSize);

      // initialize call_stub locals (step 2)

      // now save tos as arguments_tos_address

      __ std(tos, _entry_frame_locals_neg(arguments_tos_address), r_entryframe_fp);

      // load argument registers for call

      __ mr(R19_method, r_arg_method);

      __ mr(R16_thread, r_arg_thread);

      assert(tos != r_arg_method, "trashed r_arg_method");

      assert(tos != r_arg_thread && R19_method != r_arg_thread, "trashed r_arg_thread");

      // Set R15_prev_state to 0 for simplifying checks in callee.

      __ load_const_optimized(R25_templateTableBase, (address)Interpreter::dispatch_table((TosState)0), R11_scratch1);

      // Stack on entry to frame manager / native entry:

      //

      //      F0      [TOP_IJAVA_FRAME_ABI]

      //              alignment (optional)

      //              [outgoing Java arguments]

      //              [ENTRY_FRAME_LOCALS]

      //      F1      [C_FRAME]

      //              ...

      //

      // global toc register

      __ load_const_optimized(R29_TOC, MacroAssembler::global_toc(), R11_scratch1);

      // Remember the senderSP so we interpreter can pop c2i arguments off of the stack

      // when called via a c2i.

      // Pass initial_caller_sp to framemanager.

      __ mr(R21_sender_SP, R1_SP);

      // Do a light-weight C-call here, r_new_arg_entry holds the address

      // of the interpreter entry point (frame manager or native entry)

      // and save runtime-value of LR in return_address.

      assert(r_new_arg_entry != tos && r_new_arg_entry != R19_method && r_new_arg_entry != R16_thread,

             "trashed r_new_arg_entry");

      return_address = __ call_stub(r_new_arg_entry);

    }

    {

      BLOCK_COMMENT("Returned from frame manager or native entry.");

      // Returned from frame manager or native entry.

      // Now pop frame, process result, and return to caller.

      // Stack on exit from frame manager / native entry:

      //

      //      F0      [ABI]

      //              ...

      //              [ENTRY_FRAME_LOCALS]

      //      F1      [C_FRAME]

      //              ...

      //

      // Just pop the topmost frame ...

      //

      Label ret_is_object;

      Label ret_is_long;

      Label ret_is_float;

      Label ret_is_double;

      Register r_entryframe_fp = R30;

      Register r_lr            = R7_ARG5;

      Register r_cr            = R8_ARG6;

      // Reload some volatile registers which we've spilled before the call

      // to frame manager / native entry.

      // Access all locals via frame pointer, because we know nothing about

      // the topmost frame's size.

      __ ld(r_entryframe_fp, _abi(callers_sp), R1_SP);

      assert_different_registers(r_entryframe_fp, R3_RET, r_arg_result_addr, r_arg_result_type, r_cr, r_lr);

      __ ld(r_arg_result_addr,

            _entry_frame_locals_neg(result_address), r_entryframe_fp);

      __ ld(r_arg_result_type,

            _entry_frame_locals_neg(result_type), r_entryframe_fp);

      __ ld(r_cr, _abi(cr), r_entryframe_fp);

      __ ld(r_lr, _abi(lr), r_entryframe_fp);

      // pop frame and restore non-volatiles, LR and CR

      __ mr(R1_SP, r_entryframe_fp);

      __ mtcr(r_cr);

      __ mtlr(r_lr);

      // Store result depending on type. Everything that is not

      // T_OBJECT, T_LONG, T_FLOAT, or T_DOUBLE is treated as T_INT.

      __ cmpwi(CCR0, r_arg_result_type, T_OBJECT);

      __ cmpwi(CCR1, r_arg_result_type, T_LONG);

      __ cmpwi(CCR5, r_arg_result_type, T_FLOAT);

      __ cmpwi(CCR6, r_arg_result_type, T_DOUBLE);

      // restore non-volatile registers

      __ restore_nonvolatile_gprs(R1_SP, _spill_nonvolatiles_neg(r14));

      // Stack on exit from call_stub:

      //

      //      0       [C_FRAME]

      //              ...

      //

      //  no call_stub frames left.

      // All non-volatiles have been restored at this point!!

      assert(R3_RET == R3, "R3_RET should be R3");

      __ beq(CCR0, ret_is_object);

      __ beq(CCR1, ret_is_long);

      __ beq(CCR5, ret_is_float);

      __ beq(CCR6, ret_is_double);

      // default:

      __ stw(R3_RET, 0, r_arg_result_addr);

      __ blr(); // return to caller

      // case T_OBJECT:

      __ bind(ret_is_object);

      __ std(R3_RET, 0, r_arg_result_addr);

      __ blr(); // return to caller

      // case T_LONG:

      __ bind(ret_is_long);

      __ std(R3_RET, 0, r_arg_result_addr);

      __ blr(); // return to caller

      // case T_FLOAT:

      __ bind(ret_is_float);

      __ stfs(F1_RET, 0, r_arg_result_addr);

      __ blr(); // return to caller

      // case T_DOUBLE:

      __ bind(ret_is_double);

      __ stfd(F1_RET, 0, r_arg_result_addr);

      __ blr(); // return to caller

    }

    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.

  //

  address generate_catch_exception() {

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

    address start = __ pc();

    // Registers alive

    //

    //  R16_thread

    //  R3_ARG1 - address of pending exception

    //  R4_ARG2 - return address in call stub

    const Register exception_file = R21_tmp1;

    const Register exception_line = R22_tmp2;

    __ load_const(exception_file, (void*)__FILE__);

    __ load_const(exception_line, (void*)__LINE__);

    __ std(R3_ARG1, in_bytes(JavaThread::pending_exception_offset()), R16_thread);

    // store into `char *'

    __ std(exception_file, in_bytes(JavaThread::exception_file_offset()), R16_thread);

    // store into `int'

    __ stw(exception_line, in_bytes(JavaThread::exception_line_offset()), R16_thread);

    // complete return to VM

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

    __ mtlr(R4_ARG2);

    // continue in call stub

    __ blr();

    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.

  //

  // Read:

  //

  //   LR:     The pc the runtime library callee wants to return to.

  //           Since the exception occurred in the callee, the return pc

  //           from the point of view of Java is the exception pc.

  //   thread: Needed for method handles.

  //

  // Invalidate:

  //

  //   volatile registers (except below).

  //

  // Update:

  //

  //   R4_ARG2: exception

  //

  // (LR is unchanged and is live out).

  //

  address generate_forward_exception() {

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

    address start = __ pc();

#if !defined(PRODUCT)

    if (VerifyOops) {

      // Get pending exception oop.

      __ ld(R3_ARG1,

                in_bytes(Thread::pending_exception_offset()),

                R16_thread);

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

      {

        Label L;

        __ cmpdi(CCR0, R3_ARG1, 0);

        __ bne(CCR0, L);

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

        __ bind(L);

      }

      __ verify_oop(R3_ARG1, "StubRoutines::forward exception: not an oop");

    }

#endif

    // Save LR/CR and copy exception pc (LR) into R4_ARG2.

    __ save_LR_CR(R4_ARG2);

    __ push_frame_reg_args(0, R0);

    // Find exception handler.

    __ call_VM_leaf(CAST_FROM_FN_PTR(address,

                     SharedRuntime::exception_handler_for_return_address),

                    R16_thread,

                    R4_ARG2);

    // Copy handler's address.

    __ mtctr(R3_RET);

    __ pop_frame();

    __ restore_LR_CR(R0);

    // Set up the arguments for the exception handler:

    //  - R3_ARG1: exception oop

    //  - R4_ARG2: exception pc.

    // Load pending exception oop.

    __ ld(R3_ARG1,

              in_bytes(Thread::pending_exception_offset()),

              R16_thread);

    // The exception pc is the return address in the caller.

    // Must load it into R4_ARG2.

    __ mflr(R4_ARG2);

#ifdef ASSERT

    // Make sure exception is set.

    {

      Label L;

      __ cmpdi(CCR0, R3_ARG1, 0);

      __ bne(CCR0, L);

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

      __ bind(L);

    }

#endif

    // Clear the pending exception.

    __ li(R0, 0);

    __ std(R0,

               in_bytes(Thread::pending_exception_offset()),

               R16_thread);

    // Jump to exception handler.

    __ bctr();

    return start;

  }

#undef __

#define __ masm->

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