8300265: Remove metaprogramming/isSigned.hpp

Reviewed-by: kbarrett, tschatzl

src/hotspot/share/memory/metaspace/counters.hpp

@@ -26,11 +26,12 @@
 #ifndef SHARE_MEMORY_METASPACE_COUNTERS_HPP
 #define SHARE_MEMORY_METASPACE_COUNTERS_HPP
 
-#include "metaprogramming/isSigned.hpp"
 #include "runtime/atomic.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
 
+#include <type_traits>
+
 namespace metaspace {
 
 // We seem to be counting a lot of things which makes it worthwhile to
@@ -43,7 +44,7 @@ class AbstractCounter {
   T _c;
 
   // Only allow unsigned values for now
-  STATIC_ASSERT(IsSigned<T>::value == false);
+  STATIC_ASSERT(std::is_signed<T>::value == false);
 
 public:
 
@@ -86,7 +87,7 @@ class AbstractAtomicCounter {
   volatile T _c;
 
   // Only allow unsigned values for now
-  STATIC_ASSERT(IsSigned<T>::value == false);
+  STATIC_ASSERT(std::is_signed<T>::value == false);
 
 public:
 

src/hotspot/share/runtime/atomic.hpp

@@ -27,7 +27,6 @@
 
 #include "memory/allocation.hpp"
 #include "metaprogramming/enableIf.hpp"
-#include "metaprogramming/isSigned.hpp"
 #include "metaprogramming/primitiveConversions.hpp"
 #include "runtime/orderAccess.hpp"
 #include "utilities/align.hpp"
@@ -526,10 +525,10 @@ inline D Atomic::sub(D volatile* dest, I sub_value, atomic_memory_order order) {
   STATIC_ASSERT(std::is_integral<I>::value);
   // If D is a pointer type, use [u]intptr_t as the addend type,
   // matching signedness of I.  Otherwise, use D as the addend type.
-  using PI = std::conditional_t<IsSigned<I>::value, intptr_t, uintptr_t>;
+  using PI = std::conditional_t<std::is_signed<I>::value, intptr_t, uintptr_t>;
   using AddendType = std::conditional_t<std::is_pointer<D>::value, PI, D>;
   // Only allow conversions that can't change the value.
-  STATIC_ASSERT(IsSigned<I>::value == IsSigned<AddendType>::value);
+  STATIC_ASSERT(std::is_signed<I>::value == std::is_signed<AddendType>::value);
   STATIC_ASSERT(sizeof(I) <= sizeof(AddendType));
   AddendType addend = sub_value;
   // Assumes two's complement integer representation.
@@ -675,7 +674,7 @@ struct Atomic::AddImpl<
   typename EnableIf<std::is_integral<I>::value &&
                     std::is_integral<D>::value &&
                     (sizeof(I) <= sizeof(D)) &&
-                    (IsSigned<I>::value == IsSigned<D>::value)>::type>
+                    (std::is_signed<I>::value == std::is_signed<D>::value)>::type>
 {
   static D add_and_fetch(D volatile* dest, I add_value, atomic_memory_order order) {
     D addend = add_value;
@@ -697,7 +696,7 @@ struct Atomic::AddImpl<
 
   // Type of the scaled addend.  An integral type of the same size as a
   // pointer, and the same signedness as I.
-  using SI = std::conditional_t<IsSigned<I>::value, intptr_t, uintptr_t>;
+  using SI = std::conditional_t<std::is_signed<I>::value, intptr_t, uintptr_t>;
 
   // Type of the unscaled destination.  A pointer type with pointee size == 1.
   using UP = const char*;

src/hotspot/share/utilities/population_count.hpp

@@ -26,7 +26,6 @@
 #define SHARE_UTILITIES_POPULATION_COUNT_HPP
 
 #include "metaprogramming/enableIf.hpp"
-#include "metaprogramming/isSigned.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
 
@@ -48,7 +47,7 @@ inline unsigned population_count(T x) {
   STATIC_ASSERT(BitsPerWord <= 128);
   STATIC_ASSERT(BitsPerByte == 8);
   STATIC_ASSERT(std::is_integral<T>::value);
-  STATIC_ASSERT(!IsSigned<T>::value);
+  STATIC_ASSERT(!std::is_signed<T>::value);
   // We need to take care with implicit integer promotion when dealing with
   // integers < 32-bit. We chose to do this by explicitly widening constants
   // to unsigned

test/hotspot/gtest/utilities/test_count_leading_zeros.cpp

@@ -23,17 +23,17 @@
  */
 
 #include "precompiled.hpp"
-#include "metaprogramming/isSigned.hpp"
 #include "utilities/count_leading_zeros.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "unittest.hpp"
 
 #include <limits>
+#include <type_traits>
 
 template <typename T> void one_or_two_set_bits() {
   uint32_t bit1_pos = 0;
   uint32_t bits = sizeof(T) * BitsPerByte;
-  uint32_t limit = bits - (IsSigned<T>::value ? 1 : 0);
+  uint32_t limit = bits - (std::is_signed<T>::value ? 1 : 0);
   for (uint64_t ix = 1; bit1_pos < limit; ix = ix * 2, ++bit1_pos) {
     uint32_t bit2_pos = 0;
     for (uint64_t jx = 1; bit2_pos < limit; jx = jx * 2, ++bit2_pos) {
@@ -56,7 +56,7 @@ TEST(count_leading_zeros, one_or_two_set_bits) {
 }
 
 template <typename T> void high_zeros_low_ones() {
-  uint32_t number_of_leading_zeros = (IsSigned<T>::value ? 1 : 0);
+  uint32_t number_of_leading_zeros = (std::is_signed<T>::value ? 1 : 0);
   T value = std::numeric_limits<T>::max();
   for ( ; value != 0; value >>= 1, ++number_of_leading_zeros) {
     EXPECT_EQ(number_of_leading_zeros, count_leading_zeros(value))
@@ -78,7 +78,7 @@ TEST(count_leading_zeros, high_zeros_low_ones) {
 template <typename T> void high_ones_low_zeros() {
   T value = std::numeric_limits<T>::max();
 
-  uint32_t number_of_leading_zeros = (IsSigned<T>::value ? 1 : 0);
+  uint32_t number_of_leading_zeros = (std::is_signed<T>::value ? 1 : 0);
   for (uint64_t i = 1; value != 0; value -= i, i <<= 1) {
     EXPECT_EQ(number_of_leading_zeros, count_leading_zeros(value))
       << "value = " << value;
@@ -97,4 +97,4 @@ TEST(count_leading_zeros, high_ones_low_zeros) {
   high_ones_low_zeros<uint16_t>();
   high_ones_low_zeros<uint32_t>();
   high_ones_low_zeros<uint64_t>();
-}
+}