rev 13265 : imported patch IntegerTypes
rev 13268 : [mq]: Atomic_polishing_v2

   1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_METAPROGRAMMING_INTEGERTYPES_HPP
  26 #define SHARE_VM_METAPROGRAMMING_INTEGERTYPES_HPP
  27 
  28 #include "memory/allocation.hpp"
  29 #include "utilities/debug.hpp"
  30 #include "metaprogramming/decay.hpp"
  31 #include "metaprogramming/integralConstant.hpp"
  32 #include "metaprogramming/isFloatingPoint.hpp"
  33 #include "metaprogramming/isPointer.hpp"
  34 #include "metaprogramming/isSigned.hpp"
  35 #include "metaprogramming/isIntegral.hpp"
  36 
  37 class IntegerTypes : public AllStatic {
  38 public:
  39   // Metafunction returning a canonical type of the same size and signed as T.
  40   // T must be an integral type. The canonical types are guaranteed to be
  41   // the [u]intN_t types from stdint.h
  42   template<typename T> struct Canonical;
  43 
  44   // Metafunction returning the canonical signed integral type of the
  45   // given size.
  46   template<size_t byte_size> struct SignedTypeOfSize;
  47 
  48   // Metafunction returning the canonical unsigned integral type of
  49   // the given size.
  50   template<size_t byte_size> struct UnsignedTypeOfSize;
  51 
  52   // Metafunction returning the canonical signed integral type of the
  53   // same size as T.  T must be an integral, floating point, or
  54   // pointer type.
  55   template<typename T> struct Signed;
  56 
  57   // Metafunction returning the canonical unsigned integral type of
  58   // the same size as T.  T must be an integral, floating point, or
  59   // pointer type.
  60   template<typename T> struct Unsigned;
  61 
  62   // Return a signed integral value with the same representation as x.
  63   // T must be an integral, floating point, or pointer type.
  64   // If T is a signed type, then x == cast_to_signed(x).
  65   template<typename T>
  66   static typename Signed<T>::type cast_to_signed(T x);
  67 
  68   // Return an unsigned integral value with the same representation as x.
  69   // T must be an integral, floating point, or pointer type.
  70   // If T is an unsigned type, then x == cast_to_unsigned(x).
  71   template<typename T>
  72   static typename Unsigned<T>::type cast_to_unsigned(T x);
  73 
  74   // Return a value with the same representation as x.
  75   // T must be an integral, floating point, or pointer type.
  76   // U must be an integral type.  T and U must be of the same size.
  77   // If T and U are both signed or both unsigned integral types, then
  78   // x == cast<T>(x).
  79   template<typename T, typename U>
  80   static T cast(U x);
  81 
  82 private:
  83   template<typename T, bool is_signed = IsSigned<T>::value>
  84   struct CanonicalImpl;
  85 
  86   template<typename T, bool is_pointer = IsPointer<T>::value, bool is_float = IsFloatingPoint<T>::value>
  87   struct TypeForSize;
  88 
  89   template<typename T, typename U, bool from_pointer = IsPointer<U>::value, bool from_float = IsFloatingPoint<U>::value>
  90   struct CastTo;
  91 
  92   template<typename T,
  93            typename U,
  94            bool same_size = sizeof(T) == sizeof(U),
  95            bool to_pointer = IsPointer<T>::value,
  96            bool to_float = IsFloatingPoint<T>::value>
  97   struct Cast;
  98 
  99   template<typename T, typename U> static T cast_integral(U x);
 100   template<typename T, typename U> static T cast_floating_point(U x);
 101 };
 102 
 103 // Convert between different integral types of the same size.
 104 // See C++03 3.10/15 for discussion of reinterpret_cast to a reference
 105 // as a means for converting integral types while keeping the representation.
 106 template<typename T, typename U>
 107 inline T IntegerTypes::cast_integral(U x) {
 108   STATIC_ASSERT(sizeof(T) == sizeof(U));
 109   return reinterpret_cast<T&>(x);
 110 }
 111 
 112 // Convert between an integral type and a floating point type of the
 113 // same size.  The only truly correct way to do this is with memcpy.
 114 // Both the union trick and type punning via casts are undefined
 115 // behavior. gcc generates exactly the same code for all three methods,
 116 // except where the UB of type punning causes it to go off into the weeds.
 117 // (gcc explicitly supports the union trick.)  Other compilers may vary.
 118 // In particular, not all compilers do a good job with the memcpy.
 119 template<typename T, typename U>
 120 inline T IntegerTypes::cast_floating_point(U x) {
 121   STATIC_ASSERT(sizeof(T) == sizeof(U));
 122   T result;
 123   memcpy(&result, &x, sizeof(x));
 124   return result;
 125 }
 126 
 127 //////////////////////////////////////////////////////////////////////////////
 128 // SignedTypeOfSize<size_t> and UnsignedTypeOfSize<size_t>
 129 
 130 #define DEFINE_CANONICAL_SIGNED_TYPE(T)                                 \
 131   template<>                                                            \
 132   struct IntegerTypes::SignedTypeOfSize<sizeof(T)> : public AllStatic { \
 133     typedef T type;                                                     \
 134   };
 135 
 136 #define DEFINE_CANONICAL_UNSIGNED_TYPE(T)                               \
 137   template<>                                                            \
 138   struct IntegerTypes::UnsignedTypeOfSize<sizeof(T)> : public AllStatic { \
 139     typedef T type;                                                     \
 140   };
 141 
 142 #define DEFINE_INTEGER_TYPES_OF_SIZE(NBITS)            \
 143   DEFINE_CANONICAL_SIGNED_TYPE(int ## NBITS ## _t)     \
 144   DEFINE_CANONICAL_UNSIGNED_TYPE(uint ## NBITS ## _t)
 145 
 146 DEFINE_INTEGER_TYPES_OF_SIZE(8)
 147 DEFINE_INTEGER_TYPES_OF_SIZE(16)
 148 DEFINE_INTEGER_TYPES_OF_SIZE(32)
 149 DEFINE_INTEGER_TYPES_OF_SIZE(64)
 150 
 151 #undef DEFINE_INTEGER_TYPES_OF_SIZE
 152 #undef DEFINE_CANONICAL_SIGNED_TYPE
 153 #undef DEFINE_CANONICAL_UNSIGNED_TYPE
 154 
 155 //////////////////////////////////////////////////////////////////////////////
 156 // Canonical<T>
 157 
 158 template<typename T>
 159 struct IntegerTypes::CanonicalImpl<T, true>
 160   : public SignedTypeOfSize<sizeof(T)>
 161 { };
 162 
 163 template<typename T>
 164 struct IntegerTypes::CanonicalImpl<T, false>
 165   : public UnsignedTypeOfSize<sizeof(T)>
 166 { };
 167 
 168 template<typename T>
 169 struct IntegerTypes::Canonical : public CanonicalImpl<T> {
 170   STATIC_ASSERT((IsIntegral<T>::value));
 171 };
 172 
 173 //////////////////////////////////////////////////////////////////////////////
 174 // Signed<T> and Unsigned<T>
 175 
 176 // For other types, use the canonical type, ensuring T is integral.
 177 template<typename T>
 178 struct IntegerTypes::TypeForSize<T, false, false> : public Canonical<T> { };
 179 
 180 // For floating point types, use the type.
 181 template<typename T>
 182 struct IntegerTypes::TypeForSize<T, false, true> : public AllStatic {
 183   typedef T type;
 184 };
 185 
 186 // For pointer types, use void*.
 187 template<typename T>
 188 struct IntegerTypes::TypeForSize<T, true, false> : public AllStatic {
 189   typedef void* type;
 190 };
 191 
 192 template<typename T>
 193 struct IntegerTypes::Signed
 194   : public SignedTypeOfSize<sizeof(typename TypeForSize<T>::type)>
 195 { };
 196 
 197 template<typename T>
 198 struct IntegerTypes::Unsigned
 199   : public UnsignedTypeOfSize<sizeof(typename TypeForSize<T>::type)>
 200 { };
 201 
 202 //////////////////////////////////////////////////////////////////////////////
 203 // cast<T>(x)
 204 //
 205 // Cast from an integral type to an integral, floating point, or pointer type.
 206 // Cast<T, U, same_size, to_pointer, to_float>
 207 
 208 // Cast integral value to some different type of integral value.
 209 template<typename T, typename U>
 210 struct IntegerTypes::Cast<T, U, true, false, false> VALUE_OBJ_CLASS_SPEC {
 211   T operator()(U x) const {
 212     // Canonicalization verifies T is integral.
 213     typedef typename Canonical<T>::type canonical_type;
 214     return static_cast<T>(cast_integral<canonical_type>(x));
 215   }
 216 };
 217 
 218 // Cast integral value to floating point.
 219 template<typename T, typename U>
 220 struct IntegerTypes::Cast<T, U, true, false, true> VALUE_OBJ_CLASS_SPEC {
 221   T operator()(U x) const { return cast_floating_point<T>(x); }
 222 };
 223 
 224 // Cast integral value to pointer.
 225 template<typename T, typename U>
 226 struct IntegerTypes::Cast<T, U, true, true, false> VALUE_OBJ_CLASS_SPEC {
 227   T operator()(U x) const { return (T)((void*)x); }
 228 };
 229 
 230 // Same integral type is identity conversion.
 231 template<typename T>
 232 struct IntegerTypes::Cast<T, T, true, false, false> VALUE_OBJ_CLASS_SPEC {
 233   T operator()(T x) const { return x; }
 234 };
 235 
 236 // Give an informative error if the sizes differ.
 237 template<typename T, typename U, bool to_pointer, bool to_float>
 238 struct IntegerTypes::Cast<T, U, false, to_pointer, to_float> VALUE_OBJ_CLASS_SPEC {
 239   STATIC_ASSERT(sizeof(T) == sizeof(U));
 240 };
 241 
 242 template<typename T, typename U>
 243 inline T IntegerTypes::cast(U x) {
 244   // Canonicalization verifies U is integral.
 245   typedef typename Canonical<U>::type parameter_type;
 246   return Cast<T, parameter_type>()(static_cast<parameter_type>(x));
 247 }
 248 
 249 //////////////////////////////////////////////////////////////////////////////
 250 // cast_to_signed(x)
 251 // cast_to_unsigned(x)
 252 //
 253 // Cast from an integral, floating point, or pointer type to an integral type.
 254 
 255 // Cast integral to different integral.
 256 template<typename T, typename U>
 257 struct IntegerTypes::CastTo<T, U, false, false> VALUE_OBJ_CLASS_SPEC {
 258   T operator()(U x) const { return cast_integral<T>(x); }
 259 };
 260 
 261 // Cast floating point to integral value.
 262 template<typename T, typename U>
 263 struct IntegerTypes::CastTo<T, U, false, true> VALUE_OBJ_CLASS_SPEC {
 264   T operator()(U x) const { return cast_floating_point<T>(x); }
 265 };
 266 
 267 // Cast pointer to integral value.
 268 template<typename T, typename U>
 269 struct IntegerTypes::CastTo<T, U, true, false> VALUE_OBJ_CLASS_SPEC {
 270   T operator()(U x) const { return reinterpret_cast<T>(x); }
 271 };
 272 
 273 // Identity conversion
 274 template<typename T>
 275 struct IntegerTypes::CastTo<T, T, false, false> VALUE_OBJ_CLASS_SPEC {
 276   T operator()(T x) const { return x; }
 277 };
 278 
 279 template<typename T>
 280 inline typename IntegerTypes::Signed<T>::type
 281 IntegerTypes::cast_to_signed(T x) {
 282   typedef typename Signed<T>::type result_type;
 283   return CastTo<result_type, T>()(x);
 284 }
 285 
 286 template<typename T>
 287 inline typename IntegerTypes::Unsigned<T>::type
 288 IntegerTypes::cast_to_unsigned(T x) {
 289   typedef typename Unsigned<T>::type result_type;
 290   return CastTo<result_type, T>()(x);
 291 }
 292 
 293 #endif // SHARE_VM_METAPROGRAMMING_INTEGERTYPES_HPP
--- EOF ---