/*
 * 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_METAPROGRAMMING_INTEGERTYPES_HPP
#define SHARE_VM_METAPROGRAMMING_INTEGERTYPES_HPP

#include "memory/allocation.hpp"
#include "utilities/debug.hpp"
#include "metaprogramming/decay.hpp"
#include "metaprogramming/integralConstant.hpp"
#include "metaprogramming/isFloatingPoint.hpp"
#include "metaprogramming/isPointer.hpp"
#include "metaprogramming/isSigned.hpp"
#include "metaprogramming/isIntegral.hpp"

class IntegerTypes : public AllStatic {
public:
  // Metafunction returning a canonical type of the same size and signed as T.
  // T must be an integral type. The canonical types are guaranteed to be
  // the [u]intN_t types from stdint.h
  template<typename T> struct Canonical;

  // Metafunction returning the canonical signed integral type of the
  // given size.
  template<size_t byte_size> struct SignedTypeOfSize;

  // Metafunction returning the canonical unsigned integral type of
  // the given size.
  template<size_t byte_size> struct UnsignedTypeOfSize;

  // Metafunction returning the canonical signed integral type of the
  // same size as T.  T must be an integral, floating point, or
  // pointer type.
  template<typename T> struct Signed;

  // Metafunction returning the canonical unsigned integral type of
  // the same size as T.  T must be an integral, floating point, or
  // pointer type.
  template<typename T> struct Unsigned;

  // Return a signed integral value with the same representation as x.
  // T must be an integral, floating point, or pointer type.
  // If T is a signed type, then x == cast_to_signed(x).
  template<typename T>
  static typename Signed<T>::type cast_to_signed(T x);

  // Return an unsigned integral value with the same representation as x.
  // T must be an integral, floating point, or pointer type.
  // If T is an unsigned type, then x == cast_to_unsigned(x).
  template<typename T>
  static typename Unsigned<T>::type cast_to_unsigned(T x);

  // Return a value with the same representation as x.
  // T must be an integral, floating point, or pointer type.
  // U must be an integral type.  T and U must be of the same size.
  // If T and U are both signed or both unsigned integral types, then
  // x == cast<T>(x).
  template<typename T, typename U>
  static T cast(U x);

private:
  template<typename T, bool is_signed = IsSigned<T>::value>
  struct CanonicalImpl;

  template<typename T, bool is_pointer = IsPointer<T>::value, bool is_float = IsFloatingPoint<T>::value>
  struct TypeForSize;

  template<typename T, typename U, bool from_pointer = IsPointer<U>::value, bool from_float = IsFloatingPoint<U>::value>
  struct CastTo;

  template<typename T,
           typename U,
           bool same_size = sizeof(T) == sizeof(U),
           bool to_pointer = IsPointer<T>::value,
           bool to_float = IsFloatingPoint<T>::value>
  struct Cast;

  template<typename T, typename U> static T cast_integral(U x);
  template<typename T, typename U> static T cast_floating_point(U x);
};

// Convert between different integral types of the same size.
// See C++03 3.10/15 for discussion of reinterpret_cast to a reference
// as a means for converting integral types while keeping the representation.
template<typename T, typename U>
inline T IntegerTypes::cast_integral(U x) {
  STATIC_ASSERT(sizeof(T) == sizeof(U));
  return reinterpret_cast<T&>(x);
}

// Convert between an integral type and a floating point type of the
// same size.  The only truly correct way to do this is with memcpy.
// Both the union trick and type punning via casts are undefined
// behavior. gcc generates exactly the same code for all three methods,
// except where the UB of type punning causes it to go off into the weeds.
// (gcc explicitly supports the union trick.)  Other compilers may vary.
// In particular, not all compilers do a good job with the memcpy.
template<typename T, typename U>
inline T IntegerTypes::cast_floating_point(U x) {
  STATIC_ASSERT(sizeof(T) == sizeof(U));
  T result;
  memcpy(&result, &x, sizeof(x));
  return result;
}

//////////////////////////////////////////////////////////////////////////////
// SignedTypeOfSize<size_t> and UnsignedTypeOfSize<size_t>

#define DEFINE_CANONICAL_SIGNED_TYPE(T)                                 \
  template<>                                                            \
  struct IntegerTypes::SignedTypeOfSize<sizeof(T)> : public AllStatic { \
    typedef T type;                                                     \
  };

#define DEFINE_CANONICAL_UNSIGNED_TYPE(T)                               \
  template<>                                                            \
  struct IntegerTypes::UnsignedTypeOfSize<sizeof(T)> : public AllStatic { \
    typedef T type;                                                     \
  };

#define DEFINE_INTEGER_TYPES_OF_SIZE(NBITS)            \
  DEFINE_CANONICAL_SIGNED_TYPE(int ## NBITS ## _t)     \
  DEFINE_CANONICAL_UNSIGNED_TYPE(uint ## NBITS ## _t)

DEFINE_INTEGER_TYPES_OF_SIZE(8)
DEFINE_INTEGER_TYPES_OF_SIZE(16)
DEFINE_INTEGER_TYPES_OF_SIZE(32)
DEFINE_INTEGER_TYPES_OF_SIZE(64)

#undef DEFINE_INTEGER_TYPES_OF_SIZE
#undef DEFINE_CANONICAL_SIGNED_TYPE
#undef DEFINE_CANONICAL_UNSIGNED_TYPE

//////////////////////////////////////////////////////////////////////////////
// Canonical<T>

template<typename T>
struct IntegerTypes::CanonicalImpl<T, true>
  : public SignedTypeOfSize<sizeof(T)>
{ };

template<typename T>
struct IntegerTypes::CanonicalImpl<T, false>
  : public UnsignedTypeOfSize<sizeof(T)>
{ };

template<typename T>
struct IntegerTypes::Canonical : public CanonicalImpl<T> {
  STATIC_ASSERT((IsIntegral<T>::value));
};

//////////////////////////////////////////////////////////////////////////////
// Signed<T> and Unsigned<T>

// For other types, use the canonical type, ensuring T is integral.
template<typename T>
struct IntegerTypes::TypeForSize<T, false, false> : public Canonical<T> { };

// For floating point types, use the type.
template<typename T>
struct IntegerTypes::TypeForSize<T, false, true> : public AllStatic {
  typedef T type;
};

// For pointer types, use void*.
template<typename T>
struct IntegerTypes::TypeForSize<T, true, false> : public AllStatic {
  typedef void* type;
};

template<typename T>
struct IntegerTypes::Signed
  : public SignedTypeOfSize<sizeof(typename TypeForSize<T>::type)>
{ };

template<typename T>
struct IntegerTypes::Unsigned
  : public UnsignedTypeOfSize<sizeof(typename TypeForSize<T>::type)>
{ };

//////////////////////////////////////////////////////////////////////////////
// cast<T>(x)
//
// Cast from an integral type to an integral, floating point, or pointer type.
// Cast<T, U, same_size, to_pointer, to_float>

// Cast integral value to some different type of integral value.
template<typename T, typename U>
struct IntegerTypes::Cast<T, U, true, false, false> VALUE_OBJ_CLASS_SPEC {
  T operator()(U x) const {
    // Canonicalization verifies T is integral.
    typedef typename Canonical<T>::type canonical_type;
    return static_cast<T>(cast_integral<canonical_type>(x));
  }
};

// Cast integral value to floating point.
template<typename T, typename U>
struct IntegerTypes::Cast<T, U, true, false, true> VALUE_OBJ_CLASS_SPEC {
  T operator()(U x) const { return cast_floating_point<T>(x); }
};

// Cast integral value to pointer.
template<typename T, typename U>
struct IntegerTypes::Cast<T, U, true, true, false> VALUE_OBJ_CLASS_SPEC {
  T operator()(U x) const { return (T)((void*)x); }
};

// Same integral type is identity conversion.
template<typename T>
struct IntegerTypes::Cast<T, T, true, false, false> VALUE_OBJ_CLASS_SPEC {
  T operator()(T x) const { return x; }
};

// Give an informative error if the sizes differ.
template<typename T, typename U, bool to_pointer, bool to_float>
struct IntegerTypes::Cast<T, U, false, to_pointer, to_float> VALUE_OBJ_CLASS_SPEC {
  STATIC_ASSERT(sizeof(T) == sizeof(U));
};

template<typename T, typename U>
inline T IntegerTypes::cast(U x) {
  // Canonicalization verifies U is integral.
  typedef typename Canonical<U>::type parameter_type;
  return Cast<T, parameter_type>()(static_cast<parameter_type>(x));
}

//////////////////////////////////////////////////////////////////////////////
// cast_to_signed(x)
// cast_to_unsigned(x)
//
// Cast from an integral, floating point, or pointer type to an integral type.

// Cast integral to different integral.
template<typename T, typename U>
struct IntegerTypes::CastTo<T, U, false, false> VALUE_OBJ_CLASS_SPEC {
  T operator()(U x) const { return cast_integral<T>(x); }
};

// Cast floating point to integral value.
template<typename T, typename U>
struct IntegerTypes::CastTo<T, U, false, true> VALUE_OBJ_CLASS_SPEC {
  T operator()(U x) const { return cast_floating_point<T>(x); }
};

// Cast pointer to integral value.
template<typename T, typename U>
struct IntegerTypes::CastTo<T, U, true, false> VALUE_OBJ_CLASS_SPEC {
  T operator()(U x) const { return reinterpret_cast<T>(x); }
};

// Identity conversion
template<typename T>
struct IntegerTypes::CastTo<T, T, false, false> VALUE_OBJ_CLASS_SPEC {
  T operator()(T x) const { return x; }
};

template<typename T>
inline typename IntegerTypes::Signed<T>::type
IntegerTypes::cast_to_signed(T x) {
  typedef typename Signed<T>::type result_type;
  return CastTo<result_type, T>()(x);
}

template<typename T>
inline typename IntegerTypes::Unsigned<T>::type
IntegerTypes::cast_to_unsigned(T x) {
  typedef typename Unsigned<T>::type result_type;
  return CastTo<result_type, T>()(x);
}

#endif // SHARE_VM_METAPROGRAMMING_INTEGERTYPES_HPP