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