--- /dev/null	2017-08-13 17:24:39.427578209 -0400
+++ new/src/share/vm/metaprogramming/integerTypes.hpp	2017-08-13 21:55:28.412892742 -0400
@@ -0,0 +1,160 @@
+/*
+ * 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/enableIf.hpp"
+#include "metaprogramming/integralConstant.hpp"
+#include "metaprogramming/isFloatingPoint.hpp"
+#include "metaprogramming/isPointer.hpp"
+#include "metaprogramming/isRegisteredEnum.hpp"
+#include "metaprogramming/isIntegral.hpp"
+
+class IntegerTypes : public AllStatic {
+public:
+  // Return a value of type T with the same representation as x.
+  //
+  // T and U must be of the same size.
+  //
+  // At least one of T or U must be an integral type.  The other must
+  // be an integral, floating point, or pointer type.
+  template<typename T, typename U> static T cast(U x);
+
+  // Support thin wrappers over primitive types.
+  // If derived from TrueType, provides representational conversion
+  // from T to some other type.  When true, must provide
+  // - Value: typedef for T.
+  // - Decayed: typedef for decayed type.
+  // - static Decayed decay(T x): return value of type Decayed with
+  //   the same representation as x.
+  // - static T recover(Decayed x): return a value of type T with the
+  //   same representation as x.
+  template<typename T> struct Translate : public FalseType {};
+
+  // Value categories.  For internal use, but needs to be public.
+  enum Category {
+    INTEGRAL,
+    ENUM,
+    FLOAT,
+    POINTER
+  };
+
+private:
+
+  template<typename T, typename Enable = void> struct GetCategory;
+
+  template<typename T,
+           typename U,
+           bool same_size = sizeof(T) == sizeof(U),
+           Category to_category = GetCategory<T>::value,
+           Category from_category = GetCategory<U>::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);
+};
+
+#define DEFINE_GET_CATEGORY(Predicate, Value)                           \
+  template<typename T>                                                  \
+  struct IntegerTypes::GetCategory<                                     \
+    T,                                                                  \
+    typename EnableIf<Predicate<T>::value>::type>                       \
+    : IntegralConstant<IntegerTypes::Category, IntegerTypes::Value>     \
+  {};
+
+DEFINE_GET_CATEGORY(IsIntegral, INTEGRAL)
+DEFINE_GET_CATEGORY(IsRegisteredEnum, ENUM)
+DEFINE_GET_CATEGORY(IsFloatingPoint, FLOAT)
+DEFINE_GET_CATEGORY(IsPointer, POINTER)
+
+#undef DEFINE_GET_CATEGORY
+
+// 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;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// cast<T>(x)
+//
+// Cast<T, U, same_size, to_category, from_category>
+
+// Give an informative error if the sizes differ.
+template<typename T, typename U,
+         IntegerTypes::Category to_category,
+         IntegerTypes::Category from_category>
+struct IntegerTypes::Cast<T, U, false, to_category, from_category>
+  VALUE_OBJ_CLASS_SPEC
+{
+  STATIC_ASSERT(sizeof(T) == sizeof(U));
+};
+
+#define DEFINE_INTEGER_TYPES_CAST(To, From, Convert)    \
+  template<typename T, typename U>                      \
+  struct IntegerTypes::Cast<T, U, true,                 \
+                            IntegerTypes::To,           \
+			    IntegerTypes::From>         \
+    VALUE_OBJ_CLASS_SPEC                                \
+  {                                                     \
+    T operator()(U x) const { return Convert<T>(x); }   \
+  };
+
+DEFINE_INTEGER_TYPES_CAST(INTEGRAL, INTEGRAL, cast_integral)
+DEFINE_INTEGER_TYPES_CAST(ENUM,     INTEGRAL, cast_integral)
+DEFINE_INTEGER_TYPES_CAST(INTEGRAL, ENUM,     cast_integral)
+DEFINE_INTEGER_TYPES_CAST(FLOAT,    INTEGRAL, cast_floating_point)
+DEFINE_INTEGER_TYPES_CAST(INTEGRAL, FLOAT,    cast_floating_point)
+DEFINE_INTEGER_TYPES_CAST(POINTER,  INTEGRAL, reinterpret_cast)
+DEFINE_INTEGER_TYPES_CAST(INTEGRAL, POINTER,  reinterpret_cast)
+
+#undef DEFINE_INTEGER_TYPES_CAST
+
+template<typename T, typename U>
+inline T IntegerTypes::cast(U x) {
+  return Cast<T, U>()(x);
+}
+
+#endif // SHARE_VM_METAPROGRAMMING_INTEGERTYPES_HPP