--- /dev/null	2017-03-07 11:44:12.271151064 +0100
+++ new/src/share/vm/runtime/accessBackend.hpp	2017-04-25 16:46:39.075170871 +0200
@@ -0,0 +1,482 @@
+/*
+ * Copyright (c) 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.
+ *
+ */
+
+#ifndef SHARE_VM_RUNTIME_ACCESSBACKEND_HPP
+#define SHARE_VM_RUNTIME_ACCESSBACKEND_HPP
+
+#include "utilities/traits/enableIf.hpp"
+#include "utilities/traits/typeIf.hpp"
+#include "utilities/traits/integer.hpp"
+#include "utilities/traits/isDerived.hpp"
+#include "utilities/traits/isFloatLike.hpp"
+#include "utilities/traits/isVolatile.hpp"
+
+enum BarrierType {
+  BARRIER_STORE,
+  BARRIER_STORE_AT,
+  BARRIER_LOAD,
+  BARRIER_LOAD_AT,
+  BARRIER_CAS,
+  BARRIER_CAS_AT,
+  BARRIER_SWAP,
+  BARRIER_SWAP_AT,
+  BARRIER_COPY,
+  BARRIER_CLONE
+};
+
+enum {
+  RAW_DECORATOR_MASK = MO_RELAXED | MO_VOLATILE | MO_ATOMIC | MO_ACQUIRE | MO_RELEASE | MO_SEQ_CST | DEST_CONJOINT | DEST_DISJOINT | COPY_ARRAYOF | ACCESS_ARRAYCOPY | ACCESS_ATOMIC | ACCESS_ALIGNED
+};
+
+enum {
+  BASIC_DECORATOR_MASK = RAW_DECORATOR_MASK | GC_CONVERT_COMPRESSED_OOP | RT_USE_COMPRESSED_OOPS | VALUE_NOT_NULL | VALUE_IS_OOP | ACCESS_ON_ANONYMOUS
+};
+
+template <DecoratorSet decorators, typename T>
+struct TestEncodable {
+  enum {
+    value = DecoratorTest<decorators>::HAS_VALUE_IS_OOP && DecoratorTest<decorators>::NEEDS_OOP_COMPRESS
+  };
+};
+
+template <bool compress, typename T>
+struct EncodedTypeHelper {
+  typedef T type;
+};
+
+template <typename T>
+struct EncodedTypeHelper<true, T> {
+  typedef narrowOop type;
+};
+
+template <DecoratorSet decorators, typename T>
+struct EncodedType {
+  typedef typename EncodedTypeHelper<TestEncodable<decorators, T>::value, T>::type type;
+};
+
+template <DecoratorSet decorators>
+struct EncodedOopType {
+  typedef typename EncodedTypeHelper<TestEncodable<decorators, oop>::value, oop>::type type;
+};
+
+template <typename T, DecoratorSet ds>
+struct PossiblyLockedAccess {
+  enum {
+#ifndef SUPPORTS_NATIVE_CX8
+    value = (sizeof(T) == sizeof(int64_t)) && DecoratorTest<ds>::HAS_MO_ATOMIC
+#else
+    value = false
+#endif
+  };
+};
+
+template <bool on_heap, bool on_nmethod, bool on_klass>
+struct BaseTypeHelper {
+  typedef void* type;
+};
+
+template <>
+struct BaseTypeHelper<true, false, false> {
+  typedef oop type;
+};
+
+template <>
+struct BaseTypeHelper<false, true, false> {
+  typedef nmethod* type;
+};
+
+template <>
+struct BaseTypeHelper<false, false, true> {
+  typedef Klass* type;
+};
+
+template <DecoratorSet decorators>
+struct BaseType {
+  typedef typename BaseTypeHelper<DecoratorTest<decorators>::HAS_ACCESS_ON_HEAP,
+                                  DecoratorTest<decorators>::HAS_ACCESS_ON_NMETHOD,
+                                  DecoratorTest<decorators>::HAS_ACCESS_ON_KLASS>::type type;
+};
+
+namespace AccessInternal {
+  template <DecoratorSet decorators, typename T>
+  struct AccessFunctionTypes {
+    typedef void (*store_func_t)(void* addr, T value);
+    typedef void (*store_at_func_t)(typename BaseType<decorators>::type base, ptrdiff_t offset, T value);
+    typedef T (*load_func_t)(void* addr);
+    typedef T (*load_at_func_t)(typename BaseType<decorators>::type, ptrdiff_t offset);
+    typedef T (*cas_func_t)(T new_value, void* addr, T compare_value);
+    typedef T (*cas_at_func_t)(T new_value, typename BaseType<decorators>::type, ptrdiff_t offset, T compare_value);
+    typedef T (*swap_func_t)(T new_value, void* addr);
+    typedef T (*swap_at_func_t)(T new_value, typename BaseType<decorators>::type, ptrdiff_t offset);
+    typedef bool (*copy_func_t)(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length);
+  };
+
+  bool wide_atomic_needs_locking();
+  int64_t load_locked(void* addr);
+  void store_locked(void* addr, int64_t val);
+  int64_t swap_locked(int64_t new_val, void* addr);
+  int64_t cas_locked(int64_t new_val, void* addr, int64_t expected_val);
+
+  void* field_addr(void* base, ptrdiff_t offset);
+
+  // Forward calls to Copy:: in the cpp file to reduce dependencies and allow
+  // faster build times, given how frequently included access is.
+  void copy_arrayof_conjoint_oops(void* src, void* dst, size_t length);
+  void copy_conjoint_oops(void* src, void* dst, size_t length);
+  void copy_conjoint_memory_atomic(void* src, void* dst, size_t length);
+  void copy_conjoint_jbytes(void* src, void* dst, size_t length);
+  void copy_conjoint_jlongs_atomic(void* src, void* dst, size_t length);
+  void copy_disjoint_words(void* src, void* dst, size_t length);
+}
+
+template <DecoratorSet decorators>
+class RawAccessBarrier: public AllStatic {
+protected:
+  template <typename T>
+  static typename EnableIf<IsPointerSize<T>::value, void>::type
+  atomic_store(void* addr, T value);
+
+  template <typename T>
+  static typename EnableIf<!IsPointerSize<T>::value, void>::type
+  atomic_store(void* addr, T value);
+
+  template <typename T>
+  static typename EnableIf<IsPointerSize<T>::value, void>::type
+  release_store(void* addr, T value);
+
+  template <typename T>
+  static typename EnableIf<!IsPointerSize<T>::value, void>::type
+  release_store(void* addr, T value);
+
+  template <typename T>
+  static typename EnableIf<IsPointerSize<T>::value, void>::type
+  release_store_fence(void* addr, T value);
+
+  template <typename T>
+  static typename EnableIf<!IsPointerSize<T>::value, void>::type
+  release_store_fence(void* addr, T value);
+
+  template <typename T>
+  static typename EnableIf<IsPointerSize<T>::value, T>::type
+  atomic_load(void* addr);
+
+  template <typename T>
+  static typename EnableIf<!IsPointerSize<T>::value, T>::type
+  atomic_load(void* addr);
+
+  template <typename T>
+  static typename EnableIf<IsPointerSize<T>::value, T>::type
+  load_acquire(void* addr);
+
+  template <typename T>
+  static typename EnableIf<!IsPointerSize<T>::value, T>::type
+  load_acquire(void* addr);
+
+  template <typename T>
+  static typename EnableIf<IsPointerSize<T>::value, T>::type
+  fence_load_acquire(void* addr);
+
+  template <typename T>
+  static inline typename EnableIf<!IsPointerSize<T>::value, T>::type
+  fence_load_acquire(void* addr);
+
+  template <typename T>
+  static typename EnableIf<IsPointerSize<T>::value, T>::type
+  cas_relaxed(T new_value, void* addr, T compare_value);
+
+  template <typename T>
+  static typename EnableIf<!IsPointerSize<T>::value, T>::type
+  cas_relaxed(T new_value, void* addr, T compare_value);
+
+  template <typename T>
+  static typename EnableIf<IsPointerSize<T>::value, T>::type
+  cas_seq_cst(T new_value, void* addr, T compare_value);
+
+  template <typename T>
+  static typename EnableIf<!IsPointerSize<T>::value, T>::type
+  cas_seq_cst(T new_value, void* addr, T compare_value);
+
+  template <typename T>
+  static typename EnableIf<IsPointerSize<T>::value, T>::type
+  swap_seq_cst(T new_value, void* addr);
+
+  template <typename T>
+  static typename EnableIf<!IsPointerSize<T>::value, T>::type
+  swap_seq_cst(T new_value, void* addr);
+
+  // The following *_locked mechanisms serve the purpose of handling atomic operations
+  // that are larger than a machine can handle, and then possibly opt for using
+  // a slower path using a mutex to perform the operation.
+
+  template <typename T>
+  static inline T load_not_locked(void* addr) {
+    if (DecoratorTest<decorators>::HAS_MO_SEQ_CST) {
+      return fence_load_acquire<T>(addr);
+    } else if (DecoratorTest<decorators>::HAS_MO_ACQUIRE) {
+      return load_acquire<T>(addr);
+    } else if (DecoratorTest<decorators>::HAS_MO_ATOMIC) {
+      return atomic_load<T>(addr);
+    } else if (DecoratorTest<decorators>::HAS_MO_VOLATILE) {
+      return *(volatile T*)addr;
+    } else {
+      return *(T*)addr;
+    }
+  }
+
+  template <typename T, DecoratorSet ds>
+  static inline typename EnableIf<!PossiblyLockedAccess<T, ds>::value, T>::type load_maybe_locked(void* addr) {
+    return load_not_locked<T>(addr);
+  }
+
+  template <typename T, DecoratorSet ds>
+  static typename EnableIf<PossiblyLockedAccess<T, ds>::value, T>::type load_maybe_locked(void* addr);
+
+  template <typename T>
+  static inline void store_not_locked(void* addr, T value) {
+    if (DecoratorTest<decorators>::HAS_MO_SEQ_CST) {
+      release_store_fence<T>(addr, value);
+    } else if (DecoratorTest<decorators>::HAS_MO_RELEASE) {
+      release_store<T>(addr, value);
+    } else if (DecoratorTest<decorators>::HAS_MO_ATOMIC) {
+      atomic_store<T>(addr, value);
+    } else if (DecoratorTest<decorators>::HAS_MO_VOLATILE) {
+      (void)const_cast<T&>(*(volatile T*)addr = value);
+    } else {
+      *(T*)addr = value;
+    }
+  }
+
+  template <typename T, DecoratorSet ds>
+  static inline typename EnableIf<!PossiblyLockedAccess<T, ds>::value, void>::type store_maybe_locked(void* addr, T value) {
+    store_not_locked<T>(addr, value);
+  }
+
+  template <typename T, DecoratorSet ds>
+  static typename EnableIf<PossiblyLockedAccess<T, ds>::value, void>::type store_maybe_locked(void* addr, T value);
+
+  template <typename T>
+  static inline T cas_not_locked(T new_value, void* addr, T compare_value) {
+    if (DecoratorTest<decorators>::HAS_MO_SEQ_CST) {
+      return cas_seq_cst<T>(new_value, addr, compare_value);
+    } else {
+      return cas_relaxed<T>(new_value, addr, compare_value);
+    }
+  }
+
+  template <typename T, DecoratorSet ds>
+  static inline typename EnableIf<!PossiblyLockedAccess<T, ds>::value, T>::type cas_maybe_locked(T new_value, void* addr, T compare_value) {
+    return cas_not_locked<T>(new_value, addr, compare_value);
+  }
+
+  template <typename T, DecoratorSet ds>
+  static typename EnableIf<PossiblyLockedAccess<T, ds>::value, T>::type cas_maybe_locked(T new_value, void* addr, T compare_value);
+
+  template <typename T>
+  static inline T swap_not_locked(T new_value, void* addr) {
+    return swap_seq_cst<T>(new_value, addr);
+  }
+
+  template <typename T, DecoratorSet ds>
+  static inline typename EnableIf<!PossiblyLockedAccess<T, ds>::value, T>::type swap_maybe_locked(T new_value, void* addr) {
+    return swap_not_locked<T>(new_value, addr);
+  }
+
+  template <typename T, DecoratorSet ds>
+  static typename EnableIf<PossiblyLockedAccess<T, ds>::value, T>::type swap_maybe_locked(T new_value, void* addr);
+
+public:
+  template <typename T>
+  static inline typename EnableIf<!IsFloatLike<T>::value, void>::type store(void* addr, T value) {
+    store_maybe_locked<T, decorators>(addr, value);
+  }
+
+  template <typename T>
+  static inline typename EnableIf<!IsFloatLike<T>::value, T>::type load(void* addr) {
+    return load_maybe_locked<T, decorators>(addr);
+  }
+
+  template <typename T>
+  static inline typename EnableIf<!IsFloatLike<T>::value, T>::type cas(T new_value, void* addr, T compare_value) {
+    return cas_maybe_locked<T, decorators>(new_value, addr, compare_value);
+  }
+
+  template <typename T>
+  static inline typename EnableIf<!IsFloatLike<T>::value, T>::type swap(T new_value, void* addr) {
+    return swap_maybe_locked<T, decorators>(new_value, addr);
+  }
+
+  template <typename T>
+  static typename EnableIf<!IsFloatLike<T>::value, bool>::type copy(T* src, T* dst, size_t length);
+
+  static void clone(oop src, oop dst, size_t size);
+
+  template <typename T>
+  static inline typename EnableIf<IsFloatLike<T>::value, void>::type store(void* addr, T value) {
+    typedef IntegerType<T> IntType;
+    store<typename IntType::signed_type>(addr, IntType::cast_to_signed(value));
+  }
+
+  template <typename T>
+  static inline typename EnableIf<IsFloatLike<T>::value, T>::type load(void* addr) {
+    typedef IntegerType<T> IntType;
+    return IntType::cast_from_signed(load<typename IntType::signed_type>(addr));
+  }
+
+  template <typename T>
+  static inline typename EnableIf<IsFloatLike<T>::value, T>::type cas(T new_value, void* addr, T compare_value) {
+    typedef IntegerType<T> IntType;
+    return IntType::cast_from_signed(cas<typename IntType::signed_type>(IntType::cast_to_signed(new_value), addr, IntType::cast_to_signed(compare_value)));
+  }
+
+  template <typename T>
+  static inline typename EnableIf<IsFloatLike<T>::value, T>::type swap(T new_value, void* addr) {
+    typedef IntegerType<T> IntType;
+    return IntType::cast_from_signed(cas<typename IntType::signed_type>(IntType::cast_to_signed(new_value), addr));
+  }
+
+  template <typename T>
+  static typename EnableIf<IsSame<T, double>::value, bool>::type copy(T* src, T* dst, size_t length) {
+    typedef typename IntegerType<T>::signed_type IntType;
+    return copy<IntType>((IntType*)src, (IntType*)dst, length);
+  }
+
+};
+
+
+template <DecoratorSet decorators>
+class BasicAccessBarrier: public AllStatic {
+  typedef RawAccessBarrier<DecoratorIntersection<decorators, RAW_DECORATOR_MASK>::value> Raw;
+
+protected:
+  static inline void* field_addr(void* base, ptrdiff_t byte_offset) {
+    return AccessInternal::field_addr(base, byte_offset);
+  }
+
+protected:
+  template <DecoratorSet internal_decorators, typename T>
+  static inline typename EnableIf<TestEncodable<internal_decorators, T>::value,
+                                  typename EncodedType<internal_decorators, T>::type>::type
+  encode_internal(T value);
+
+  template <DecoratorSet internal_decorators, typename T>
+  static inline typename EnableIf<!TestEncodable<internal_decorators, T>::value,
+                                  typename EncodedType<internal_decorators, T>::type>::type
+  encode_internal(T value) {
+    return value;
+  }
+
+  template <typename T>
+  static inline typename EncodedType<decorators, T>::type
+  encode(T value) {
+    return encode_internal<decorators, T>(value);
+  }
+
+  template <DecoratorSet internal_decorators, typename T>
+  static inline typename EnableIf<TestEncodable<internal_decorators, T>::value, T>::type
+  decode_internal(typename EncodedType<internal_decorators, T>::type value);
+
+  template <DecoratorSet internal_decorators, typename T>
+  static inline typename EnableIf<!TestEncodable<internal_decorators, T>::value, T>::type
+  decode_internal(typename EncodedType<internal_decorators, T>::type value) {
+    return value;
+  }
+
+  template <typename T>
+  static inline T decode(typename EncodedType<decorators, T>::type value) {
+    return decode_internal<decorators, T>(value);
+  }
+
+public:
+  template <typename T>
+  static void store(void* addr, T value) {
+    Raw::template store<T>(addr, value);
+  }
+
+  template <typename T>
+  static void store_at(void* base, ptrdiff_t offset, T value) {
+    store<T>(field_addr(base, offset), value);
+  }
+
+  template <typename T>
+  static T load(void* addr) {
+    return Raw::template load<T>(addr);
+  }
+
+  template <typename T>
+  static T load_at(void* base, ptrdiff_t offset) {
+    return load<T>(field_addr(base, offset));
+  }
+
+  template <typename T>
+  static T cas(T new_value, void* addr, T compare_value) {
+    return Raw::template cas<T>(new_value, addr, compare_value);
+  }
+
+  template <typename T>
+  static T cas_at(T new_value, void* base, ptrdiff_t offset, T compare_value) {
+    return cas<T>(new_value, field_addr(base, offset), compare_value);
+  }
+
+  template <typename T>
+  static T swap(T new_value, void* addr) {
+    return Raw::template swap<T>(new_value, addr);
+  }
+
+  template <typename T>
+  static T swap_at(T new_value, void* base, ptrdiff_t offset) {
+    return swap<T>(new_value, field_addr(base, offset));
+  }
+
+  template <typename T>
+  static bool copy(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length) {
+    return Raw::template copy<T>(src, dst, length);
+  }
+
+  template <typename T>
+  static void oop_store(void* addr, T value);
+  template <typename T>
+  static void oop_store_at(void* base, ptrdiff_t offset, T value);
+
+  template <typename T>
+  static T oop_load(void* addr);
+  template <typename T>
+  static T oop_load_at(void* base, ptrdiff_t offset);
+
+  template <typename T>
+  static T oop_cas(T new_value, void* addr, T compare_value);
+  template <typename T>
+  static T oop_cas_at(T new_value, void* base, ptrdiff_t offset, T compare_value);
+
+  template <typename T>
+  static T oop_swap(T new_value, void* addr);
+  template <typename T>
+  static T oop_swap_at(T new_value, void* base, ptrdiff_t offset);
+
+  template <typename T>
+  static bool oop_copy(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length);
+
+  static void clone(oop src, oop dst, size_t size);
+};
+
+#endif // SHARE_VM_RUNTIME_ACCESSBACKEND_HPP