/*

 * Copyright (c) 2000, 2012, 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 "classfile/vmSymbols.hpp"

#ifndef SERIALGC

#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"

#endif // SERIALGC

#include "memory/allocation.inline.hpp"

#include "prims/jni.h"

#include "prims/jvm.h"

#include "runtime/globals.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/reflection.hpp"

#include "runtime/synchronizer.hpp"

#include "services/threadService.hpp"

#include "utilities/copy.hpp"

#include "utilities/dtrace.hpp"

/*

 *      Implementation of class sun.misc.Unsafe

 */

#ifndef USDT2

HS_DTRACE_PROBE_DECL3(hotspot, thread__park__begin, uintptr_t, int, long long);

HS_DTRACE_PROBE_DECL1(hotspot, thread__park__end, uintptr_t);

HS_DTRACE_PROBE_DECL1(hotspot, thread__unpark, uintptr_t);

#endif /* !USDT2 */

#define MAX_OBJECT_SIZE \

  ( arrayOopDesc::header_size(T_DOUBLE) * HeapWordSize \

    + ((julong)max_jint * sizeof(double)) )

#define UNSAFE_ENTRY(result_type, header) \

  JVM_ENTRY(result_type, header)

// Can't use UNSAFE_LEAF because it has the signature of a straight

// call into the runtime (just like JVM_LEAF, funny that) but it's

// called like a Java Native and thus the wrapper built for it passes

// arguments like a JNI call.  It expects those arguments to be popped

// from the stack on Intel like all good JNI args are, and adjusts the

// stack according.  Since the JVM_LEAF call expects no extra

// arguments the stack isn't popped in the C code, is pushed by the

// wrapper and we get sick.

//#define UNSAFE_LEAF(result_type, header) \

//  JVM_LEAF(result_type, header)

#define UNSAFE_END JVM_END

#define UnsafeWrapper(arg) /*nothing, for the present*/

inline void* addr_from_java(jlong addr) {

  // This assert fails in a variety of ways on 32-bit systems.

  // It is impossible to predict whether native code that converts

  // pointers to longs will sign-extend or zero-extend the addresses.

  //assert(addr == (uintptr_t)addr, "must not be odd high bits");

  return (void*)(uintptr_t)addr;

}

inline jlong addr_to_java(void* p) {

  assert(p == (void*)(uintptr_t)p, "must not be odd high bits");

  return (uintptr_t)p;

}

// Note: The VM's obj_field and related accessors use byte-scaled

// ("unscaled") offsets, just as the unsafe methods do.

// However, the method Unsafe.fieldOffset explicitly declines to

// guarantee this.  The field offset values manipulated by the Java user

// through the Unsafe API are opaque cookies that just happen to be byte

// offsets.  We represent this state of affairs by passing the cookies

// through conversion functions when going between the VM and the Unsafe API.

// The conversion functions just happen to be no-ops at present.

inline jlong field_offset_to_byte_offset(jlong field_offset) {

  return field_offset;

}

inline jlong field_offset_from_byte_offset(jlong byte_offset) {

  return byte_offset;

}

inline jint invocation_key_from_method_slot(jint slot) {

  return slot;

}

inline jint invocation_key_to_method_slot(jint key) {

  return key;

}

inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {

  jlong byte_offset = field_offset_to_byte_offset(field_offset);

  // Don't allow unsafe to be used to read or write the header word of oops

  assert(p == NULL || field_offset >= oopDesc::header_size(), "offset must be outside of header");

#ifdef ASSERT

  if (p != NULL) {

    assert(byte_offset >= 0 && byte_offset <= (jlong)MAX_OBJECT_SIZE, "sane offset");

    if (byte_offset == (jint)byte_offset) {

      void* ptr_plus_disp = (address)p + byte_offset;

      assert((void*)p->obj_field_addr<oop>((jint)byte_offset) == ptr_plus_disp,

             "raw [ptr+disp] must be consistent with oop::field_base");

    }

  }

#endif

  if (sizeof(char*) == sizeof(jint))    // (this constant folds!)

    return (address)p + (jint) byte_offset;

  else

    return (address)p +        byte_offset;

}

// Externally callable versions:

// (Use these in compiler intrinsics which emulate unsafe primitives.)

jlong Unsafe_field_offset_to_byte_offset(jlong field_offset) {

  return field_offset;

}

jlong Unsafe_field_offset_from_byte_offset(jlong byte_offset) {

  return byte_offset;

}

jint Unsafe_invocation_key_from_method_slot(jint slot) {

  return invocation_key_from_method_slot(slot);

}

jint Unsafe_invocation_key_to_method_slot(jint key) {

  return invocation_key_to_method_slot(key);

}

///// Data in the Java heap.

#define GET_FIELD(obj, offset, type_name, v) \

  oop p = JNIHandles::resolve(obj); \

  type_name v = *(type_name*)index_oop_from_field_offset_long(p, offset)

#define SET_FIELD(obj, offset, type_name, x) \

  oop p = JNIHandles::resolve(obj); \

  *(type_name*)index_oop_from_field_offset_long(p, offset) = x

#define GET_FIELD_VOLATILE(obj, offset, type_name, v) \

  oop p = JNIHandles::resolve(obj); \

  volatile type_name v = OrderAccess::load_acquire((volatile type_name*)index_oop_from_field_offset_long(p, offset));

#define SET_FIELD_VOLATILE(obj, offset, type_name, x) \

  oop p = JNIHandles::resolve(obj); \

  OrderAccess::release_store_fence((volatile type_name*)index_oop_from_field_offset_long(p, offset), x);

// Macros for oops that check UseCompressedOops

#define GET_OOP_FIELD(obj, offset, v) \

  oop p = JNIHandles::resolve(obj);   \

  oop v;                              \

  if (UseCompressedOops) {            \

    narrowOop n = *(narrowOop*)index_oop_from_field_offset_long(p, offset); \

    v = oopDesc::decode_heap_oop(n);                                \

  } else {                            \

    v = *(oop*)index_oop_from_field_offset_long(p, offset);                 \

  }

// Get/SetObject must be special-cased, since it works with handles.

// The xxx140 variants for backward compatibility do not allow a full-width offset.

UNSAFE_ENTRY(jobject, Unsafe_GetObject140(JNIEnv *env, jobject unsafe, jobject obj, jint offset))

  UnsafeWrapper("Unsafe_GetObject");

  if (obj == NULL)  THROW_0(vmSymbols::java_lang_NullPointerException());

  GET_OOP_FIELD(obj, offset, v)

  jobject ret = JNIHandles::make_local(env, v);

#ifndef SERIALGC

  // We could be accessing the referent field in a reference

  // object. If G1 is enabled then we need to register a non-null

  // referent with the SATB barrier.

  if (UseG1GC) {

    bool needs_barrier = false;

    if (ret != NULL) {

      if (offset == java_lang_ref_Reference::referent_offset) {

        oop o = JNIHandles::resolve_non_null(obj);

        Klass* k = o->klass();

        if (InstanceKlass::cast(k)->reference_type() != REF_NONE) {

          assert(InstanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");

          needs_barrier = true;

        }

      }

    }

    if (needs_barrier) {

      oop referent = JNIHandles::resolve(ret);

      G1SATBCardTableModRefBS::enqueue(referent);

    }

  }

#endif // SERIALGC

  return ret;

UNSAFE_END

UNSAFE_ENTRY(void, Unsafe_SetObject140(JNIEnv *env, jobject unsafe, jobject obj, jint offset, jobject x_h))

  UnsafeWrapper("Unsafe_SetObject");

  if (obj == NULL)  THROW(vmSymbols::java_lang_NullPointerException());

  oop x = JNIHandles::resolve(x_h);

  //SET_FIELD(obj, offset, oop, x);

  oop p = JNIHandles::resolve(obj);

  if (UseCompressedOops) {

    if (x != NULL) {

      // If there is a heap base pointer, we are obliged to emit a store barrier.

      oop_store((narrowOop*)index_oop_from_field_offset_long(p, offset), x);

    } else {

      narrowOop n = oopDesc::encode_heap_oop_not_null(x);

      *(narrowOop*)index_oop_from_field_offset_long(p, offset) = n;

    }

  } else {

    if (x != NULL) {

      // If there is a heap base pointer, we are obliged to emit a store barrier.

      oop_store((oop*)index_oop_from_field_offset_long(p, offset), x);

    } else {

      *(oop*)index_oop_from_field_offset_long(p, offset) = x;

    }

  }

UNSAFE_END

// The normal variants allow a null base pointer with an arbitrary address.

// But if the base pointer is non-null, the offset should make some sense.

// That is, it should be in the range [0, MAX_OBJECT_SIZE].

UNSAFE_ENTRY(jobject, Unsafe_GetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))

  UnsafeWrapper("Unsafe_GetObject");

  GET_OOP_FIELD(obj, offset, v)

  jobject ret = JNIHandles::make_local(env, v);

#ifndef SERIALGC

  // We could be accessing the referent field in a reference

  // object. If G1 is enabled then we need to register non-null

  // referent with the SATB barrier.

  if (UseG1GC) {

    bool needs_barrier = false;

    if (ret != NULL) {

      if (offset == java_lang_ref_Reference::referent_offset && obj != NULL) {

        oop o = JNIHandles::resolve(obj);

        Klass* k = o->klass();

        if (InstanceKlass::cast(k)->reference_type() != REF_NONE) {

          assert(InstanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");

          needs_barrier = true;

        }

      }

    }

    if (needs_barrier) {

      oop referent = JNIHandles::resolve(ret);

      G1SATBCardTableModRefBS::enqueue(referent);

    }

  }

#endif // SERIALGC

  return ret;

UNSAFE_END

UNSAFE_ENTRY(void, Unsafe_SetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))

  UnsafeWrapper("Unsafe_SetObject");

  oop x = JNIHandles::resolve(x_h);

  oop p = JNIHandles::resolve(obj);

  if (UseCompressedOops) {

    oop_store((narrowOop*)index_oop_from_field_offset_long(p, offset), x);

  } else {

    oop_store((oop*)index_oop_from_field_offset_long(p, offset), x);

  }

UNSAFE_END

UNSAFE_ENTRY(jobject, Unsafe_GetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))

  UnsafeWrapper("Unsafe_GetObjectVolatile");

  oop p = JNIHandles::resolve(obj);

  void* addr = index_oop_from_field_offset_long(p, offset);

  volatile oop v;

  if (UseCompressedOops) {

    volatile narrowOop n = *(volatile narrowOop*) addr;

    v = oopDesc::decode_heap_oop(n);

  } else {

    v = *(volatile oop*) addr;

  }

  OrderAccess::acquire();

  return JNIHandles::make_local(env, v);

UNSAFE_END

UNSAFE_ENTRY(void, Unsafe_SetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))

  UnsafeWrapper("Unsafe_SetObjectVolatile");

  oop x = JNIHandles::resolve(x_h);

  oop p = JNIHandles::resolve(obj);

  void* addr = index_oop_from_field_offset_long(p, offset);

  OrderAccess::release();

  if (UseCompressedOops) {

    oop_store((narrowOop*)addr, x);

  } else {

    oop_store((oop*)addr, x);

  }

  OrderAccess::fence();

UNSAFE_END

#if defined(SPARC) || defined(X86)

// Sparc and X86 have atomic jlong (8 bytes) instructions

#else

// Keep old code for platforms which may not have atomic jlong (8 bytes) instructions

// Volatile long versions must use locks if !VM_Version::supports_cx8().

// support_cx8 is a surrogate for 'supports atomic long memory ops'.

UNSAFE_ENTRY(jlong, Unsafe_GetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))

  UnsafeWrapper("Unsafe_GetLongVolatile");

  {

    if (VM_Version::supports_cx8()) {

      GET_FIELD_VOLATILE(obj, offset, jlong, v);

      return v;

    }

    else {

      Handle p (THREAD, JNIHandles::resolve(obj));

      jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));

      ObjectLocker ol(p, THREAD);

      jlong value = *addr;

      return value;

    }

  }

UNSAFE_END

UNSAFE_ENTRY(void, Unsafe_SetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x))

  UnsafeWrapper("Unsafe_SetLongVolatile");

  {

    if (VM_Version::supports_cx8()) {

      SET_FIELD_VOLATILE(obj, offset, jlong, x);

    }

    else {

      Handle p (THREAD, JNIHandles::resolve(obj));

      jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));

      ObjectLocker ol(p, THREAD);

      *addr = x;

    }

  }

UNSAFE_END

#endif // not SPARC and not X86

#define DEFINE_GETSETOOP(jboolean, Boolean) \

 \

UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset)) \

  UnsafeWrapper("Unsafe_Get"#Boolean); \

  if (obj == NULL)  THROW_0(vmSymbols::java_lang_NullPointerException()); \

  GET_FIELD(obj, offset, jboolean, v); \

  return v; \

UNSAFE_END \

 \

UNSAFE_ENTRY(void, Unsafe_Set##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset, jboolean x)) \

  UnsafeWrapper("Unsafe_Set"#Boolean); \

  if (obj == NULL)  THROW(vmSymbols::java_lang_NullPointerException()); \

  SET_FIELD(obj, offset, jboolean, x); \

UNSAFE_END \

 \

UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \

  UnsafeWrapper("Unsafe_Get"#Boolean); \

  GET_FIELD(obj, offset, jboolean, v); \

  return v; \

UNSAFE_END \

 \

UNSAFE_ENTRY(void, Unsafe_Set##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \

  UnsafeWrapper("Unsafe_Set"#Boolean); \

  SET_FIELD(obj, offset, jboolean, x); \

UNSAFE_END \

 \

// END DEFINE_GETSETOOP.

DEFINE_GETSETOOP(jboolean, Boolean)

DEFINE_GETSETOOP(jbyte, Byte)

DEFINE_GETSETOOP(jshort, Short);

DEFINE_GETSETOOP(jchar, Char);

DEFINE_GETSETOOP(jint, Int);

DEFINE_GETSETOOP(jlong, Long);

DEFINE_GETSETOOP(jfloat, Float);

DEFINE_GETSETOOP(jdouble, Double);

#undef DEFINE_GETSETOOP

#define DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean) \

 \

UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \

  UnsafeWrapper("Unsafe_Get"#Boolean); \

  GET_FIELD_VOLATILE(obj, offset, jboolean, v); \

  return v; \

UNSAFE_END \

 \

UNSAFE_ENTRY(void, Unsafe_Set##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \

  UnsafeWrapper("Unsafe_Set"#Boolean); \

  SET_FIELD_VOLATILE(obj, offset, jboolean, x); \

UNSAFE_END \

 \

// END DEFINE_GETSETOOP_VOLATILE.

DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean)

DEFINE_GETSETOOP_VOLATILE(jbyte, Byte)

DEFINE_GETSETOOP_VOLATILE(jshort, Short);

DEFINE_GETSETOOP_VOLATILE(jchar, Char);

DEFINE_GETSETOOP_VOLATILE(jint, Int);

DEFINE_GETSETOOP_VOLATILE(jfloat, Float);

DEFINE_GETSETOOP_VOLATILE(jdouble, Double);

#if defined(SPARC) || defined(X86)

// Sparc and X86 have atomic jlong (8 bytes) instructions

DEFINE_GETSETOOP_VOLATILE(jlong, Long);

#endif

#undef DEFINE_GETSETOOP_VOLATILE

// The non-intrinsified versions of setOrdered just use setVolatile

UNSAFE_ENTRY(void, Unsafe_SetOrderedInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint x))

  UnsafeWrapper("Unsafe_SetOrderedInt");

  SET_FIELD_VOLATILE(obj, offset, jint, x);

UNSAFE_END

UNSAFE_ENTRY(void, Unsafe_SetOrderedObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))

  UnsafeWrapper("Unsafe_SetOrderedObject");

  oop x = JNIHandles::resolve(x_h);

  oop p = JNIHandles::resolve(obj);

  void* addr = index_oop_from_field_offset_long(p, offset);

  OrderAccess::release();

  if (UseCompressedOops) {

    oop_store((narrowOop*)addr, x);

  } else {

    oop_store((oop*)addr, x);

  }

  OrderAccess::fence();

UNSAFE_END

UNSAFE_ENTRY(void, Unsafe_SetOrderedLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x))

  UnsafeWrapper("Unsafe_SetOrderedLong");

#if defined(SPARC) || defined(X86)

  // Sparc and X86 have atomic jlong (8 bytes) instructions

  SET_FIELD_VOLATILE(obj, offset, jlong, x);

#else

  // Keep old code for platforms which may not have atomic long (8 bytes) instructions

  {

    if (VM_Version::supports_cx8()) {

      SET_FIELD_VOLATILE(obj, offset, jlong, x);

    }

    else {

      Handle p (THREAD, JNIHandles::resolve(obj));

      jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));

      ObjectLocker ol(p, THREAD);

      *addr = x;

    }

  }

#endif

UNSAFE_END

////// Data in the C heap.

// Note:  These do not throw NullPointerException for bad pointers.

// They just crash.  Only a oop base pointer can generate a NullPointerException.

//

#define DEFINE_GETSETNATIVE(java_type, Type, native_type) \

 \

UNSAFE_ENTRY(java_type, Unsafe_GetNative##Type(JNIEnv *env, jobject unsafe, jlong addr)) \

  UnsafeWrapper("Unsafe_GetNative"#Type); \

  void* p = addr_from_java(addr); \

  JavaThread* t = JavaThread::current(); \

  t->set_doing_unsafe_access(true); \

  java_type x = *(volatile native_type*)p; \

  t->set_doing_unsafe_access(false); \

  return x; \

UNSAFE_END \

 \

UNSAFE_ENTRY(void, Unsafe_SetNative##Type(JNIEnv *env, jobject unsafe, jlong addr, java_type x)) \

  UnsafeWrapper("Unsafe_SetNative"#Type); \

  JavaThread* t = JavaThread::current(); \

  t->set_doing_unsafe_access(true); \

  void* p = addr_from_java(addr); \

  *(volatile native_type*)p = x; \

  t->set_doing_unsafe_access(false); \

UNSAFE_END \

 \

// END DEFINE_GETSETNATIVE.

DEFINE_GETSETNATIVE(jbyte, Byte, signed char)

DEFINE_GETSETNATIVE(jshort, Short, signed short);

DEFINE_GETSETNATIVE(jchar, Char, unsigned short);

DEFINE_GETSETNATIVE(jint, Int, jint);

// no long -- handled specially

DEFINE_GETSETNATIVE(jfloat, Float, float);

DEFINE_GETSETNATIVE(jdouble, Double, double);

#undef DEFINE_GETSETNATIVE

UNSAFE_ENTRY(jlong, Unsafe_GetNativeLong(JNIEnv *env, jobject unsafe, jlong addr))

  UnsafeWrapper("Unsafe_GetNativeLong");

  JavaThread* t = JavaThread::current();

  // We do it this way to avoid problems with access to heap using 64