/*

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

 * Copyright (c) 2016 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 "c1/c1_Defs.hpp"

#include "c1/c1_MacroAssembler.hpp"

#include "c1/c1_Runtime1.hpp"

#include "ci/ciUtilities.hpp"

#include "gc/shared/cardTable.hpp"

#include "interpreter/interpreter.hpp"

#include "nativeInst_s390.hpp"

#include "oops/compiledICHolder.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "register_s390.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/signature.hpp"

#include "runtime/vframeArray.hpp"

#include "utilities/macros.hpp"

#include "vmreg_s390.inline.hpp"

#include "registerSaver_s390.hpp"

#if INCLUDE_ALL_GCS

#include "gc/g1/g1BarrierSet.hpp"

#include "gc/g1/g1CardTable.hpp"

#endif

// Implementation of StubAssembler

int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry_point, int number_of_arguments) {

  set_num_rt_args(0); // Nothing on stack.

  assert(!(oop_result1->is_valid() || metadata_result->is_valid()) || oop_result1 != metadata_result, "registers must be different");

  // We cannot trust that code generated by the C++ compiler saves R14

  // to z_abi_160.return_pc, because sometimes it spills R14 using stmg at

  // z_abi_160.gpr14 (e.g. InterpreterRuntime::_new()).

  // Therefore we load the PC into Z_R1_scratch and let set_last_Java_frame() save

  // it into the frame anchor.

  address pc = get_PC(Z_R1_scratch);

  int call_offset = (int)(pc - addr_at(0));

  set_last_Java_frame(Z_SP, Z_R1_scratch);

  // ARG1 must hold thread address.

  z_lgr(Z_ARG1, Z_thread);

  address return_pc = NULL;

  align_call_far_patchable(this->pc());

  return_pc = call_c_opt(entry_point);

  assert(return_pc != NULL, "const section overflow");

  reset_last_Java_frame();

  // Check for pending exceptions.

  {

    load_and_test_long(Z_R0_scratch, Address(Z_thread, Thread::pending_exception_offset()));

    // This used to conditionally jump to forward_exception however it is

    // possible if we relocate that the branch will not reach. So we must jump

    // around so we can always reach.

    Label ok;

    z_bre(ok); // Bcondequal is the same as bcondZero.

    // exception pending => forward to exception handler

    // Make sure that the vm_results are cleared.

    if (oop_result1->is_valid()) {

      clear_mem(Address(Z_thread, JavaThread::vm_result_offset()), sizeof(jlong));

    }

    if (metadata_result->is_valid()) {

      clear_mem(Address(Z_thread, JavaThread::vm_result_2_offset()), sizeof(jlong));

    }

    if (frame_size() == no_frame_size) {

      // Pop the stub frame.

      pop_frame();

      restore_return_pc();

      load_const_optimized(Z_R1, StubRoutines::forward_exception_entry());

      z_br(Z_R1);

    } else if (_stub_id == Runtime1::forward_exception_id) {

      should_not_reach_here();

    } else {

      load_const_optimized(Z_R1, Runtime1::entry_for (Runtime1::forward_exception_id));

      z_br(Z_R1);

    }

    bind(ok);

  }

  // Get oop results if there are any and reset the values in the thread.

  if (oop_result1->is_valid()) {

    get_vm_result(oop_result1);

  }

  if (metadata_result->is_valid()) {

    get_vm_result_2(metadata_result);

  }

  return call_offset;

}

int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1) {

  // Z_ARG1 is reserved for the thread.

  lgr_if_needed(Z_ARG2, arg1);

  return call_RT(oop_result1, metadata_result, entry, 1);

}

int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2) {

  // Z_ARG1 is reserved for the thread.

  lgr_if_needed(Z_ARG2, arg1);

  assert(arg2 != Z_ARG2, "smashed argument");

  lgr_if_needed(Z_ARG3, arg2);

  return call_RT(oop_result1, metadata_result, entry, 2);

}

int StubAssembler::call_RT(Register oop_result1, Register metadata_result, address entry, Register arg1, Register arg2, Register arg3) {

  // Z_ARG1 is reserved for the thread.

  lgr_if_needed(Z_ARG2, arg1);

  assert(arg2 != Z_ARG2, "smashed argument");

  lgr_if_needed(Z_ARG3, arg2);

  assert(arg3 != Z_ARG3, "smashed argument");

  lgr_if_needed(Z_ARG4, arg3);

  return call_RT(oop_result1, metadata_result, entry, 3);

}

// Implementation of Runtime1

#define __ sasm->

#ifndef PRODUCT

#undef  __

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

#endif // !PRODUCT

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

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

static OopMap* generate_oop_map(StubAssembler* sasm) {

  RegisterSaver::RegisterSet reg_set = RegisterSaver::all_registers;

  int frame_size_in_slots =

    RegisterSaver::live_reg_frame_size(reg_set) / VMRegImpl::stack_slot_size;

  sasm->set_frame_size(frame_size_in_slots / VMRegImpl::slots_per_word);

  return RegisterSaver::generate_oop_map(sasm, reg_set);

}

static OopMap* save_live_registers(StubAssembler* sasm, bool save_fpu_registers = true, Register return_pc = Z_R14) {

  __ block_comment("save_live_registers");

  RegisterSaver::RegisterSet reg_set =

    save_fpu_registers ? RegisterSaver::all_registers : RegisterSaver::all_integer_registers;

  int frame_size_in_slots =

    RegisterSaver::live_reg_frame_size(reg_set) / VMRegImpl::stack_slot_size;

  sasm->set_frame_size(frame_size_in_slots / VMRegImpl::slots_per_word);

  return RegisterSaver::save_live_registers(sasm, reg_set, return_pc);

}

static OopMap* save_live_registers_except_r2(StubAssembler* sasm, bool save_fpu_registers = true) {

  if (!save_fpu_registers) {

    __ unimplemented(FILE_AND_LINE);

  }

  __ block_comment("save_live_registers");

  RegisterSaver::RegisterSet reg_set = RegisterSaver::all_registers_except_r2;

  int frame_size_in_slots =

      RegisterSaver::live_reg_frame_size(reg_set) / VMRegImpl::stack_slot_size;

  sasm->set_frame_size(frame_size_in_slots / VMRegImpl::slots_per_word);

  return RegisterSaver::save_live_registers(sasm, reg_set);

}

static OopMap* save_volatile_registers(StubAssembler* sasm, Register return_pc = Z_R14) {

  __ block_comment("save_volatile_registers");

  RegisterSaver::RegisterSet reg_set = RegisterSaver::all_volatile_registers;

  int frame_size_in_slots =

    RegisterSaver::live_reg_frame_size(reg_set) / VMRegImpl::stack_slot_size;

  sasm->set_frame_size(frame_size_in_slots / VMRegImpl::slots_per_word);

  return RegisterSaver::save_live_registers(sasm, reg_set, return_pc);

}

static void restore_live_registers(StubAssembler* sasm, bool restore_fpu_registers = true) {

  __ block_comment("restore_live_registers");

  RegisterSaver::RegisterSet reg_set =

    restore_fpu_registers ? RegisterSaver::all_registers : RegisterSaver::all_integer_registers;

  RegisterSaver::restore_live_registers(sasm, reg_set);

}

static void restore_live_registers_except_r2(StubAssembler* sasm, bool restore_fpu_registers = true) {

  if (!restore_fpu_registers) {

    __ unimplemented(FILE_AND_LINE);

  }

  __ block_comment("restore_live_registers_except_r2");

  RegisterSaver::restore_live_registers(sasm, RegisterSaver::all_registers_except_r2);

}

static void restore_volatile_registers(StubAssembler* sasm) {

  __ block_comment("restore_volatile_registers");

  RegisterSaver::RegisterSet reg_set = RegisterSaver::all_volatile_registers;

  RegisterSaver::restore_live_registers(sasm, reg_set);

}

void Runtime1::initialize_pd() {

  // Nothing to do.

}

OopMapSet* Runtime1::generate_exception_throw(StubAssembler* sasm, address target, bool has_argument) {

  // Make a frame and preserve the caller's caller-save registers.

  OopMap* oop_map = save_live_registers(sasm);

  int call_offset;

  if (!has_argument) {

    call_offset = __ call_RT(noreg, noreg, target);

  } else {

    call_offset = __ call_RT(noreg, noreg, target, Z_R1_scratch, Z_R0_scratch);

  }

  OopMapSet* oop_maps = new OopMapSet();

  oop_maps->add_gc_map(call_offset, oop_map);

  __ should_not_reach_here();

  return oop_maps;

}

void Runtime1::generate_unwind_exception(StubAssembler *sasm) {

  // Incoming parameters: Z_EXC_OOP and Z_EXC_PC.

  // Keep copies in callee-saved registers during runtime call.

  const Register exception_oop_callee_saved = Z_R11;

  const Register exception_pc_callee_saved = Z_R12;

  // Other registers used in this stub.

  const Register handler_addr = Z_R4;

  // Verify that only exception_oop, is valid at this time.

  __ invalidate_registers(Z_EXC_OOP, Z_EXC_PC);

  // Check that fields in JavaThread for exception oop and issuing pc are set.

  __ asm_assert_mem8_is_zero(in_bytes(JavaThread::exception_oop_offset()), Z_thread, "exception oop already set : " FILE_AND_LINE, 0);

  __ asm_assert_mem8_is_zero(in_bytes(JavaThread::exception_pc_offset()), Z_thread, "exception pc already set : " FILE_AND_LINE, 0);

  // Save exception_oop and pc in callee-saved register to preserve it

  // during runtime calls.

  __ verify_not_null_oop(Z_EXC_OOP);

  __ lgr_if_needed(exception_oop_callee_saved, Z_EXC_OOP);

  __ lgr_if_needed(exception_pc_callee_saved, Z_EXC_PC);

  __ push_frame_abi160(0); // Runtime code needs the z_abi_160.

  // Search the exception handler address of the caller (using the return address).

  __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), Z_thread, Z_EXC_PC);

  // Z_RET(Z_R2): exception handler address of the caller.

  __ pop_frame();

  __ invalidate_registers(exception_oop_callee_saved, exception_pc_callee_saved, Z_RET);

  // Move result of call into correct register.

  __ lgr_if_needed(handler_addr, Z_RET);

  // Restore exception oop and pc to Z_EXC_OOP and Z_EXC_PC (required convention of exception handler).

  __ lgr_if_needed(Z_EXC_OOP, exception_oop_callee_saved);

  __ lgr_if_needed(Z_EXC_PC, exception_pc_callee_saved);

  // Verify that there is really a valid exception in Z_EXC_OOP.

  __ verify_not_null_oop(Z_EXC_OOP);

  __ z_br(handler_addr); // Jump to exception handler.

}

OopMapSet* Runtime1::generate_patching(StubAssembler* sasm, address target) {

  // Make a frame and preserve the caller's caller-save registers.

  OopMap* oop_map = save_live_registers(sasm);

  // Call the runtime patching routine, returns non-zero if nmethod got deopted.

  int call_offset = __ call_RT(noreg, noreg, target);

  OopMapSet* oop_maps = new OopMapSet();

  oop_maps->add_gc_map(call_offset, oop_map);

  // Re-execute the patched instruction or, if the nmethod was

  // deoptmized, return to the deoptimization handler entry that will

  // cause re-execution of the current bytecode.

  DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();

  assert(deopt_blob != NULL, "deoptimization blob must have been created");

  __ z_ltr(Z_RET, Z_RET); // return value == 0

  restore_live_registers(sasm);

  __ z_bcr(Assembler::bcondZero, Z_R14);

  // Return to the deoptimization handler entry for unpacking and

  // rexecute if we simply returned then we'd deopt as if any call we

  // patched had just returned.

  AddressLiteral dest(deopt_blob->unpack_with_reexecution());

  __ load_const_optimized(Z_R1_scratch, dest);

  __ z_br(Z_R1_scratch);

  return oop_maps;

}

OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {

  // for better readability

  const bool must_gc_arguments = true;

  const bool dont_gc_arguments = false;

  // Default value; overwritten for some optimized stubs that are

  // called from methods that do not use the fpu.

  bool save_fpu_registers = true;

  // Stub code and info for the different stubs.

  OopMapSet* oop_maps = NULL;

  switch (id) {

    case forward_exception_id:

      {

        oop_maps = generate_handle_exception(id, sasm);

        // will not return

      }

      break;

    case new_instance_id:

    case fast_new_instance_id:

    case fast_new_instance_init_check_id:

      {

        Register klass    = Z_R11; // Incoming

        Register obj      = Z_R2;  // Result

        if (id == new_instance_id) {

          __ set_info("new_instance", dont_gc_arguments);

        } else if (id == fast_new_instance_id) {

          __ set_info("fast new_instance", dont_gc_arguments);

        } else {

          assert(id == fast_new_instance_init_check_id, "bad StubID");

          __ set_info("fast new_instance init check", dont_gc_arguments);

        }

        OopMap* map = save_live_registers_except_r2(sasm);

        int call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_instance), klass);

        oop_maps = new OopMapSet();

        oop_maps->add_gc_map(call_offset, map);

        restore_live_registers_except_r2(sasm);

        __ verify_oop(obj);

        __ z_br(Z_R14);

      }

      break;

    case counter_overflow_id:

      {

        // Arguments :

        //   bci    : stack param 0

        //   method : stack param 1

        //

        Register bci = Z_ARG2, method = Z_ARG3;

        // frame size in bytes

        OopMap* map = save_live_registers(sasm);

        const int frame_size = sasm->frame_size() * VMRegImpl::slots_per_word * VMRegImpl::stack_slot_size;

        __ z_lg(bci,    0*BytesPerWord + FrameMap::first_available_sp_in_frame + frame_size, Z_SP);

        __ z_lg(method, 1*BytesPerWord + FrameMap::first_available_sp_in_frame + frame_size, Z_SP);

        int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, counter_overflow), bci, method);

        oop_maps = new OopMapSet();

        oop_maps->add_gc_map(call_offset, map);

        restore_live_registers(sasm);

        __ z_br(Z_R14);

      }

      break;

    case new_type_array_id:

    case new_object_array_id:

      {

        Register length   = Z_R13; // Incoming

        Register klass    = Z_R11; // Incoming

        Register obj      = Z_R2;  // Result

        if (id == new_type_array_id) {

          __ set_info("new_type_array", dont_gc_arguments);

        } else {

          __ set_info("new_object_array", dont_gc_arguments);

        }

#ifdef ASSERT

        // Assert object type is really an array of the proper kind.

        {

          NearLabel ok;

          Register t0 = obj;

          __ mem2reg_opt(t0, Address(klass, Klass::layout_helper_offset()), false);

          __ z_sra(t0, Klass::_lh_array_tag_shift);

          int tag = ((id == new_type_array_id)

                     ? Klass::_lh_array_tag_type_value

                     : Klass::_lh_array_tag_obj_value);

          __ compare32_and_branch(t0, tag, Assembler::bcondEqual, ok);

          __ stop("assert(is an array klass)");

          __ should_not_reach_here();

          __ bind(ok);

        }

#endif // ASSERT

        OopMap* map = save_live_registers_except_r2(sasm);

        int call_offset;

        if (id == new_type_array_id) {

          call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_type_array), klass, length);

        } else {

          call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_object_array), klass, length);

        }

        oop_maps = new OopMapSet();

        oop_maps->add_gc_map(call_offset, map);

        restore_live_registers_except_r2(sasm);

        __ verify_oop(obj);

        __ z_br(Z_R14);

      }

      break;

    case new_multi_array_id:

      { __ set_info("new_multi_array", dont_gc_arguments);

        // Z_R3,: klass

        // Z_R4,: rank

        // Z_R5: address of 1st dimension

        OopMap* map = save_live_registers(sasm);

        int call_offset = __ call_RT(Z_R2, noreg, CAST_FROM_FN_PTR(address, new_multi_array), Z_R3, Z_R4, Z_R5);

        oop_maps = new OopMapSet();

        oop_maps->add_gc_map(call_offset, map);

        restore_live_registers_except_r2(sasm);

        // Z_R2,: new multi array

        __ verify_oop(Z_R2);

        __ z_br(Z_R14);

      }

      break;

    case register_finalizer_id:

      {

        __ set_info("register_finalizer", dont_gc_arguments);

        // Load the klass and check the has finalizer flag.

        Register klass = Z_ARG2;

        __ load_klass(klass, Z_ARG1);

        __ testbit(Address(klass, Klass::access_flags_offset()), exact_log2(JVM_ACC_HAS_FINALIZER));

        __ z_bcr(Assembler::bcondAllZero, Z_R14); // Return if bit is not set.

        OopMap* oop_map = save_live_registers(sasm);

        int call_offset = __ call_RT(noreg, noreg,

                                     CAST_FROM_FN_PTR(address, SharedRuntime::register_finalizer), Z_ARG1);

        oop_maps = new OopMapSet();

        oop_maps->add_gc_map(call_offset, oop_map);

        // Now restore all the live registers.

        restore_live_registers(sasm);

        __ z_br(Z_R14);

      }

      break;

    case throw_range_check_failed_id:

      { __ set_info("range_check_failed", dont_gc_arguments);

        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_range_check_exception), true);

      }

      break;

    case throw_index_exception_id:

      { __ set_info("index_range_check_failed", dont_gc_arguments);

        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_index_exception), true);

      }

      break;

    case throw_div0_exception_id:

      { __ set_info("throw_div0_exception", dont_gc_arguments);

        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_div0_exception), false);

      }

      break;

    case throw_null_pointer_exception_id:

      { __ set_info("throw_null_pointer_exception", dont_gc_arguments);

        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_null_pointer_exception), false);

      }

      break;

    case handle_exception_nofpu_id:

    case handle_exception_id:

      { __ set_info("handle_exception", dont_gc_arguments);

        oop_maps = generate_handle_exception(id, sasm);

      }

      break;

    case handle_exception_from_callee_id:

      { __ set_info("handle_exception_from_callee", dont_gc_arguments);

        oop_maps = generate_handle_exception(id, sasm);

      }

      break;

    case unwind_exception_id:

      { __ set_info("unwind_exception", dont_gc_arguments);

        // Note: no stubframe since we are about to leave the current

        // activation and we are calling a leaf VM function only.

        generate_unwind_exception(sasm);

      }

      break;

    case throw_array_store_exception_id:

      { __ set_info("throw_array_store_exception", dont_gc_arguments);

        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_array_store_exception), true);

      }

      break;

    case throw_class_cast_exception_id:

    { // Z_R1_scratch: object

      __ set_info("throw_class_cast_exception", dont_gc_arguments);

      oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_class_cast_exception), true);

    }

    break;

    case throw_incompatible_class_change_error_id:

      { __ set_info("throw_incompatible_class_cast_exception", dont_gc_arguments);

        oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_incompatible_class_change_error), false);

      }

      break;

    case slow_subtype_check_id:

    {

      // Arguments :