/*

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

 * Copyright (c) 2016, 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 "registerSaver_s390.hpp"

#include "gc/shared/barrierSet.hpp"

#include "gc/shared/barrierSetAssembler.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interp_masm.hpp"

#include "memory/universe.hpp"

#include "nativeInst_s390.hpp"

#include "oops/instanceOop.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"

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

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

// see the comment in stubRoutines.hpp.

#ifdef PRODUCT

#define __ _masm->

#else

#define __ (Verbose ? (_masm->block_comment(FILE_AND_LINE),_masm):_masm)->

#endif

#define BLOCK_COMMENT(str) if (PrintAssembly) __ block_comment(str)

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

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

// Stub Code definitions

class StubGenerator: public StubCodeGenerator {

 private:

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

  // Call stubs are used to call Java from C.

  //

  // Arguments:

  //

  //   R2        - call wrapper address     : address

  //   R3        - result                   : intptr_t*

  //   R4        - result type              : BasicType

  //   R5        - method                   : method

  //   R6        - frame mgr entry point    : address

  //   [SP+160]  - parameter block          : intptr_t*

  //   [SP+172]  - parameter count in words : int

  //   [SP+176]  - thread                   : Thread*

  //

  address generate_call_stub(address& return_address) {

    // Set up a new C frame, copy Java arguments, call frame manager

    // or native_entry, and process result.

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

    address start = __ pc();

    Register r_arg_call_wrapper_addr   = Z_ARG1;

    Register r_arg_result_addr         = Z_ARG2;

    Register r_arg_result_type         = Z_ARG3;

    Register r_arg_method              = Z_ARG4;

    Register r_arg_entry               = Z_ARG5;

    // offsets to fp

    #define d_arg_thread 176

    #define d_arg_argument_addr 160

    #define d_arg_argument_count 168+4

    Register r_entryframe_fp           = Z_tmp_1;

    Register r_top_of_arguments_addr   = Z_ARG4;

    Register r_new_arg_entry = Z_R14;

    // macros for frame offsets

    #define call_wrapper_address_offset \

               _z_entry_frame_locals_neg(call_wrapper_address)

    #define result_address_offset \

              _z_entry_frame_locals_neg(result_address)

    #define result_type_offset \

              _z_entry_frame_locals_neg(result_type)

    #define arguments_tos_address_offset \

              _z_entry_frame_locals_neg(arguments_tos_address)

    {

      //

      // STACK on entry to call_stub:

      //

      //     F1      [C_FRAME]

      //            ...

      //

      Register r_argument_addr              = Z_tmp_3;

      Register r_argumentcopy_addr          = Z_tmp_4;

      Register r_argument_size_in_bytes     = Z_ARG5;

      Register r_frame_size                 = Z_R1;

      Label arguments_copied;

      // Save non-volatile registers to ABI of caller frame.

      BLOCK_COMMENT("save registers, push frame {");

      __ z_stmg(Z_R6, Z_R14, 16, Z_SP);

      __ z_std(Z_F8, 96, Z_SP);

      __ z_std(Z_F9, 104, Z_SP);

      __ z_std(Z_F10, 112, Z_SP);

      __ z_std(Z_F11, 120, Z_SP);

      __ z_std(Z_F12, 128, Z_SP);

      __ z_std(Z_F13, 136, Z_SP);

      __ z_std(Z_F14, 144, Z_SP);

      __ z_std(Z_F15, 152, Z_SP);

      //

      // Push ENTRY_FRAME including arguments:

      //

      //     F0      [TOP_IJAVA_FRAME_ABI]

      //             [outgoing Java arguments]

      //             [ENTRY_FRAME_LOCALS]

      //     F1      [C_FRAME]

      //             ...

      //

      // Calculate new frame size and push frame.

      #define abi_plus_locals_size \

                (frame::z_top_ijava_frame_abi_size + frame::z_entry_frame_locals_size)

      if (abi_plus_locals_size % BytesPerWord == 0) {

        // Preload constant part of frame size.

        __ load_const_optimized(r_frame_size, -abi_plus_locals_size/BytesPerWord);

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

        __ z_lgr(r_entryframe_fp, Z_SP);

        // Add space required by arguments to frame size.

        __ z_slgf(r_frame_size, d_arg_argument_count, Z_R0, Z_SP);

        // Move Z_ARG5 early, it will be used as a local.

        __ z_lgr(r_new_arg_entry, r_arg_entry);

        // Convert frame size from words to bytes.

        __ z_sllg(r_frame_size, r_frame_size, LogBytesPerWord);

        __ push_frame(r_frame_size, r_entryframe_fp,

                      false/*don't copy SP*/, true /*frame size sign inverted*/);

      } else {

        guarantee(false, "frame sizes should be multiples of word size (BytesPerWord)");

      }

      BLOCK_COMMENT("} save, push");

      // Load argument registers for call.

      BLOCK_COMMENT("prepare/copy arguments {");

      __ z_lgr(Z_method, r_arg_method);

      __ z_lg(Z_thread, d_arg_thread, r_entryframe_fp);

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

      // Wimply use SP + frame::top_ijava_frame_size.

      __ add2reg(r_top_of_arguments_addr,

                 frame::z_top_ijava_frame_abi_size - BytesPerWord, Z_SP);

      // Initialize call_stub locals (step 1).

      if ((call_wrapper_address_offset + BytesPerWord == result_address_offset) &&

          (result_address_offset + BytesPerWord == result_type_offset)          &&

          (result_type_offset + BytesPerWord == arguments_tos_address_offset)) {

        __ z_stmg(r_arg_call_wrapper_addr, r_top_of_arguments_addr,

                  call_wrapper_address_offset, r_entryframe_fp);

      } else {

        __ z_stg(r_arg_call_wrapper_addr,

                 call_wrapper_address_offset, r_entryframe_fp);

        __ z_stg(r_arg_result_addr,

                 result_address_offset, r_entryframe_fp);

        __ z_stg(r_arg_result_type,

                 result_type_offset, r_entryframe_fp);

        __ z_stg(r_top_of_arguments_addr,

                 arguments_tos_address_offset, r_entryframe_fp);

      }

      // Copy Java arguments.

      // Any arguments to copy?

      __ load_and_test_int2long(Z_R1, Address(r_entryframe_fp, d_arg_argument_count));

      __ z_bre(arguments_copied);

      // Prepare loop and copy arguments in reverse order.

      {

        // Calculate argument size in bytes.

        __ z_sllg(r_argument_size_in_bytes, Z_R1, LogBytesPerWord);

        // Get addr of first incoming Java argument.

        __ z_lg(r_argument_addr, d_arg_argument_addr, r_entryframe_fp);

        // Let r_argumentcopy_addr point to last outgoing Java argument.

        __ add2reg(r_argumentcopy_addr, BytesPerWord, r_top_of_arguments_addr); // = Z_SP+160 effectively.

        // Let r_argument_addr point to last incoming Java argument.

        __ add2reg_with_index(r_argument_addr, -BytesPerWord,

                              r_argument_size_in_bytes, r_argument_addr);

        // Now loop while Z_R1 > 0 and copy arguments.

        {

          Label next_argument;

          __ bind(next_argument);

          // Mem-mem move.

          __ z_mvc(0, BytesPerWord-1, r_argumentcopy_addr, 0, r_argument_addr);

          __ add2reg(r_argument_addr,    -BytesPerWord);

          __ add2reg(r_argumentcopy_addr, BytesPerWord);

          __ z_brct(Z_R1, next_argument);

        }

      }  // End of argument copy loop.

      __ bind(arguments_copied);

    }

    BLOCK_COMMENT("} arguments");

    BLOCK_COMMENT("call {");

    {

      // Call frame manager or native entry.

      //

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

      //

      //   Z_ARG1 = r_top_of_arguments_addr  - intptr_t *sender tos (prepushed)

      //                                       Lesp = (SP) + copied_arguments_offset - 8

      //   Z_method                          - method

      //   Z_thread                          - JavaThread*

      //

      // Here, the usual SP is the initial_caller_sp.

      __ z_lgr(Z_R10, Z_SP);

      // Z_esp points to the slot below the last argument.

      __ z_lgr(Z_esp, r_top_of_arguments_addr);

      //

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

      //

      //     F0      [TOP_IJAVA_FRAME_ABI]

      //             [outgoing Java arguments]

      //             [ENTRY_FRAME_LOCALS]

      //     F1      [C_FRAME]

      //             ...

      //

      // 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 return_pc in return_address

      // (call by reference argument).

      return_address = __ call_stub(r_new_arg_entry);

    }

    BLOCK_COMMENT("} call");

    {

      BLOCK_COMMENT("restore registers {");

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

      //

      // Restore frame pointer.

      __ z_lg(r_entryframe_fp, _z_abi(callers_sp), Z_SP);

      // Pop frame. Done here to minimize stalls.

      __ pop_frame();

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

      __ z_lg(r_arg_result_addr, result_address_offset, r_entryframe_fp);

      __ z_lg(r_arg_result_type, result_type_offset, r_entryframe_fp);

      // Restore non-volatiles.

      __ z_lmg(Z_R6, Z_R14, 16, Z_SP);

      __ z_ld(Z_F8, 96, Z_SP);

      __ z_ld(Z_F9, 104, Z_SP);

      __ z_ld(Z_F10, 112, Z_SP);

      __ z_ld(Z_F11, 120, Z_SP);

      __ z_ld(Z_F12, 128, Z_SP);

      __ z_ld(Z_F13, 136, Z_SP);

      __ z_ld(Z_F14, 144, Z_SP);

      __ z_ld(Z_F15, 152, Z_SP);

      BLOCK_COMMENT("} restore");

      //

      // Stack on exit from call_stub:

      //

      //     0       [C_FRAME]

      //             ...

      //

      // No call_stub frames left.

      //

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

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

      // The following code makes some assumptions on the T_<type> enum values.

      // The enum is defined in globalDefinitions.hpp.

      // The validity of the assumptions is tested as far as possible.

      //   The assigned values should not be shuffled

      //   T_BOOLEAN==4    - lowest used enum value

      //   T_NARROWOOP==16 - largest used enum value

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

      BLOCK_COMMENT("process result {");

      Label firstHandler;

      int   handlerLen= 8;

#ifdef ASSERT

      char  assertMsg[] = "check BasicType definition in globalDefinitions.hpp";

      __ z_chi(r_arg_result_type, T_BOOLEAN);

      __ asm_assert_low(assertMsg, 0x0234);

      __ z_chi(r_arg_result_type, T_NARROWOOP);

      __ asm_assert_high(assertMsg, 0x0235);

#endif

      __ add2reg(r_arg_result_type, -T_BOOLEAN);          // Remove offset.

      __ z_larl(Z_R1, firstHandler);                      // location of first handler

      __ z_sllg(r_arg_result_type, r_arg_result_type, 3); // Each handler is 8 bytes long.

      __ z_bc(MacroAssembler::bcondAlways, 0, r_arg_result_type, Z_R1);

      __ align(handlerLen);

      __ bind(firstHandler);

      // T_BOOLEAN:

        guarantee(T_BOOLEAN == 4, "check BasicType definition in globalDefinitions.hpp");

        __ z_st(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_CHAR:

        guarantee(T_CHAR == T_BOOLEAN+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_st(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_FLOAT:

        guarantee(T_FLOAT == T_CHAR+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_ste(Z_FRET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_DOUBLE:

        guarantee(T_DOUBLE == T_FLOAT+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_std(Z_FRET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_BYTE:

        guarantee(T_BYTE == T_DOUBLE+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_st(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_SHORT:

        guarantee(T_SHORT == T_BYTE+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_st(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_INT:

        guarantee(T_INT == T_SHORT+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_st(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_LONG:

        guarantee(T_LONG == T_INT+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_stg(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_OBJECT:

        guarantee(T_OBJECT == T_LONG+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_stg(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_ARRAY:

        guarantee(T_ARRAY == T_OBJECT+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_stg(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_VOID:

        guarantee(T_VOID == T_ARRAY+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_stg(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_ADDRESS:

        guarantee(T_ADDRESS == T_VOID+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_stg(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      // T_NARROWOOP:

        guarantee(T_NARROWOOP == T_ADDRESS+1, "check BasicType definition in globalDefinitions.hpp");

        __ z_st(Z_RET, 0, r_arg_result_addr);

        __ z_br(Z_R14); // Return to caller.

        __ align(handlerLen);

      BLOCK_COMMENT("} process result");

    }

    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

    //

    //   Z_thread

    //   Z_ARG1 - address of pending exception

    //   Z_ARG2 - return address in call stub

    //

    const Register exception_file = Z_R0;

    const Register exception_line = Z_R1;

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

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

    __ z_stg(Z_ARG1, thread_(pending_exception));

    // Store into `char *'.

    __ z_stg(exception_file, thread_(exception_file));

    // Store into `int'.

    __ z_st(exception_line, thread_(exception_line));

    // Complete return to VM.

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

    // Continue in call stub.

    __ z_br(Z_ARG2);

    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:

  //   Z_R14: 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.

  //

  // Invalidate:

  //   Volatile registers (except below).

  //

  // Update:

  //   Z_ARG1: exception

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

  //

  address generate_forward_exception() {

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

    address start = __ pc();

    #define pending_exception_offset in_bytes(Thread::pending_exception_offset())

#ifdef ASSERT

    // Get pending exception oop.

    __ z_lg(Z_ARG1, pending_exception_offset, Z_thread);

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

    {

      Label L;

      __ z_ltgr(Z_ARG1, Z_ARG1);

      __ z_brne(L);

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

      __ bind(L);

    }

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

#endif

    __ z_lgr(Z_ARG2, Z_R14); // Copy exception pc into Z_ARG2.

    __ save_return_pc();

    __ push_frame_abi160(0);

    // Find exception handler.

    __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address),

                    Z_thread,

                    Z_ARG2);

    // Copy handler's address.

    __ z_lgr(Z_R1, Z_RET);

    __ pop_frame();

    __ restore_return_pc();

    // Set up the arguments for the exception handler:

    // - Z_ARG1: exception oop

    // - Z_ARG2: exception pc

    // Load pending exception oop.

    __ z_lg(Z_ARG1, pending_exception_offset, Z_thread);

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

    // must load it into Z_ARG2

    __ z_lgr(Z_ARG2, Z_R14);

#ifdef ASSERT

    // Make sure exception is set.

    { Label L;

      __ z_ltgr(Z_ARG1, Z_ARG1);

      __ z_brne(L);

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

      __ bind(L);

    }

#endif

    // Clear the pending exception.

    __ clear_mem(Address(Z_thread, pending_exception_offset), sizeof(void *));