/*

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

#include "assembler_arm.inline.hpp"

#include "memory/resourceArea.hpp"

#include "prims/jniFastGetField.hpp"

#include "prims/jvm_misc.hpp"

#include "runtime/safepoint.hpp"

#define __ masm->

#define BUFFER_SIZE  96

address JNI_FastGetField::generate_fast_get_int_field0(BasicType type) {

  const char* name = NULL;

  address slow_case_addr = NULL;

  switch (type) {

    case T_BOOLEAN:

      name = "jni_fast_GetBooleanField";

      slow_case_addr = jni_GetBooleanField_addr();

      break;

    case T_BYTE:

      name = "jni_fast_GetByteField";

      slow_case_addr = jni_GetByteField_addr();

      break;

    case T_CHAR:

      name = "jni_fast_GetCharField";

      slow_case_addr = jni_GetCharField_addr();

      break;

    case T_SHORT:

      name = "jni_fast_GetShortField";

      slow_case_addr = jni_GetShortField_addr();

      break;

    case T_INT:

      name = "jni_fast_GetIntField";

      slow_case_addr = jni_GetIntField_addr();

      break;

    case T_LONG:

      name = "jni_fast_GetLongField";

      slow_case_addr = jni_GetLongField_addr();

      break;

    case T_FLOAT:

      name = "jni_fast_GetFloatField";

      slow_case_addr = jni_GetFloatField_addr();

      break;

    case T_DOUBLE:

      name = "jni_fast_GetDoubleField";

      slow_case_addr = jni_GetDoubleField_addr();

      break;

    default:

      ShouldNotReachHere();

  }

  // R0 - jni env

  // R1 - object handle

  // R2 - jfieldID

  const Register Rsafepoint_counter_addr = AARCH64_ONLY(R4) NOT_AARCH64(R3);

  const Register Robj = AARCH64_ONLY(R5) NOT_AARCH64(R1);

  const Register Rres = AARCH64_ONLY(R6) NOT_AARCH64(R0);

#ifndef AARCH64

  const Register Rres_hi = R1;

#endif // !AARCH64

  const Register Rsafept_cnt = Rtemp;

  const Register Rsafept_cnt2 = Rsafepoint_counter_addr;

  const Register Rtmp1 = AARCH64_ONLY(R7) NOT_AARCH64(R3); // same as Rsafepoint_counter_addr on 32-bit ARM

  const Register Rtmp2 = AARCH64_ONLY(R8) NOT_AARCH64(R2); // same as jfieldID on 32-bit ARM

#ifdef AARCH64

  assert_different_registers(Rsafepoint_counter_addr, Rsafept_cnt, Robj, Rres, Rtmp1, Rtmp2, R0, R1, R2, LR);

  assert_different_registers(Rsafept_cnt2, Rsafept_cnt, Rres, R0, R1, R2, LR);

#else

  assert_different_registers(Rsafepoint_counter_addr, Rsafept_cnt, Robj, Rres, LR);

  assert_different_registers(Rsafept_cnt, R1, R2, Rtmp1, LR);

  assert_different_registers(Rsafepoint_counter_addr, Rsafept_cnt, Rres, Rres_hi, Rtmp2, LR);

  assert_different_registers(Rsafept_cnt2, Rsafept_cnt, Rres, Rres_hi, LR);

#endif // AARCH64

  address fast_entry;

  ResourceMark rm;

  BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE);

  CodeBuffer cbuf(blob);

  MacroAssembler* masm = new MacroAssembler(&cbuf);

  fast_entry = __ pc();

  // Safepoint check

  InlinedAddress safepoint_counter_addr(SafepointSynchronize::safepoint_counter_addr());

  Label slow_case;

  __ ldr_literal(Rsafepoint_counter_addr, safepoint_counter_addr);

#ifndef AARCH64

  __ push(RegisterSet(R0, R3));  // save incoming arguments for slow case

#endif // !AARCH64

  __ ldr_s32(Rsafept_cnt, Address(Rsafepoint_counter_addr));

  __ tbnz(Rsafept_cnt, 0, slow_case);

#ifdef AARCH64

  // If mask changes we need to ensure that the inverse is still encodable as an immediate

  STATIC_ASSERT(JNIHandles::weak_tag_mask == 1);

  __ andr(R1, R1, ~JNIHandles::weak_tag_mask);

#else

  __ bic(R1, R1, JNIHandles::weak_tag_mask);

#endif

  if (os::is_MP()) {

    // Address dependency restricts memory access ordering. It's cheaper than explicit LoadLoad barrier

    __ andr(Rtmp1, Rsafept_cnt, (unsigned)1);

    __ ldr(Robj, Address(R1, Rtmp1));

  } else {

    __ ldr(Robj, Address(R1));

  }

#ifdef AARCH64

  __ add(Robj, Robj, AsmOperand(R2, lsr, 2));

  Address field_addr = Address(Robj);

#else

  Address field_addr;

  if (type != T_BOOLEAN

      && type != T_INT

#ifndef __ABI_HARD__

      && type != T_FLOAT

#endif // !__ABI_HARD__

      ) {

    // Only ldr and ldrb support embedded shift, other loads do not

    __ add(Robj, Robj, AsmOperand(R2, lsr, 2));

    field_addr = Address(Robj);

  } else {

    field_addr = Address(Robj, R2, lsr, 2);

  }

#endif // AARCH64

  assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");

  speculative_load_pclist[count] = __ pc();

  switch (type) {

    case T_BOOLEAN:

      __ ldrb(Rres, field_addr);

      break;

    case T_BYTE:

      __ ldrsb(Rres, field_addr);

      break;

    case T_CHAR:

      __ ldrh(Rres, field_addr);

      break;

    case T_SHORT:

      __ ldrsh(Rres, field_addr);

      break;

    case T_INT:

#ifndef __ABI_HARD__

    case T_FLOAT:

#endif

      __ ldr_s32(Rres, field_addr);

      break;

    case T_LONG:

#ifndef __ABI_HARD__

    case T_DOUBLE:

#endif

#ifdef AARCH64

      __ ldr(Rres, field_addr);

#else

      // Safe to use ldrd since long and double fields are 8-byte aligned

      __ ldrd(Rres, field_addr);

#endif // AARCH64

      break;

#ifdef __ABI_HARD__

    case T_FLOAT:

      __ ldr_float(S0, field_addr);

      break;

    case T_DOUBLE:

      __ ldr_double(D0, field_addr);

      break;

#endif // __ABI_HARD__

    default:

      ShouldNotReachHere();

  }

  if(os::is_MP()) {

      // Address dependency restricts memory access ordering. It's cheaper than explicit LoadLoad barrier

#if defined(__ABI_HARD__) && !defined(AARCH64)

    if (type == T_FLOAT || type == T_DOUBLE) {

      __ ldr_literal(Rsafepoint_counter_addr, safepoint_counter_addr);

      __ fmrrd(Rres, Rres_hi, D0);

      __ eor(Rtmp2, Rres, Rres);

      __ ldr_s32(Rsafept_cnt2, Address(Rsafepoint_counter_addr, Rtmp2));

    } else

#endif // __ABI_HARD__ && !AARCH64

    {

#ifndef AARCH64

      __ ldr_literal(Rsafepoint_counter_addr, safepoint_counter_addr);

#endif // !AARCH64

      __ eor(Rtmp2, Rres, Rres);

      __ ldr_s32(Rsafept_cnt2, Address(Rsafepoint_counter_addr, Rtmp2));

    }

  } else {

    __ ldr_s32(Rsafept_cnt2, Address(Rsafepoint_counter_addr));

  }

  __ cmp(Rsafept_cnt2, Rsafept_cnt);

#ifdef AARCH64

  __ b(slow_case, ne);

  __ mov(R0, Rres);

  __ ret();

#else

  // discards saved R0 R1 R2 R3

  __ add(SP, SP, 4 * wordSize, eq);

  __ bx(LR, eq);

#endif // AARCH64

  slowcase_entry_pclist[count++] = __ pc();

  __ bind(slow_case);

#ifndef AARCH64

  __ pop(RegisterSet(R0, R3));

#endif // !AARCH64

  // thumb mode switch handled by MacroAssembler::jump if needed

  __ jump(slow_case_addr, relocInfo::none, Rtemp);

  __ bind_literal(safepoint_counter_addr);

  __ flush();

  guarantee((__ pc() - fast_entry) <= BUFFER_SIZE, "BUFFER_SIZE too small");

  return fast_entry;

}

address JNI_FastGetField::generate_fast_get_float_field0(BasicType type) {

  ShouldNotReachHere();

  return NULL;

}

address JNI_FastGetField::generate_fast_get_boolean_field() {

  return generate_fast_get_int_field0(T_BOOLEAN);

}

address JNI_FastGetField::generate_fast_get_byte_field() {

  return generate_fast_get_int_field0(T_BYTE);

}

address JNI_FastGetField::generate_fast_get_char_field() {

  return generate_fast_get_int_field0(T_CHAR);

}

address JNI_FastGetField::generate_fast_get_short_field() {

  return generate_fast_get_int_field0(T_SHORT);

}

address JNI_FastGetField::generate_fast_get_int_field() {

  return generate_fast_get_int_field0(T_INT);

}

address JNI_FastGetField::generate_fast_get_long_field() {

  return generate_fast_get_int_field0(T_LONG);

}

address JNI_FastGetField::generate_fast_get_float_field() {

  return generate_fast_get_int_field0(T_FLOAT);

}

address JNI_FastGetField::generate_fast_get_double_field() {

  return generate_fast_get_int_field0(T_DOUBLE);

}