Centralize a couple JIT arithmetic helpers (dotnet#127781)

Author: tannergooding

src/coreclr/jit/bitset.cpp

@@ -10,13 +10,6 @@
 #include "bitsetasshortlong.h"
 #include "bitsetasuint64inclass.h"
 
-// clang-format off
-unsigned BitSetSupport::BitCountTable[16] = { 0, 1, 1, 2,
-                                              1, 2, 2, 3,
-                                              1, 2, 2, 3,
-                                              2, 3, 3, 4 };
-// clang-format on
-
 #ifdef DEBUG
 template <typename BitSetType, unsigned Uniq, typename Env, typename BitSetTraits>
 void BitSetSupport::RunTests(Env env)

src/coreclr/jit/bitset.h

@@ -20,23 +20,6 @@ class BitSetSupport
 public:
     static const unsigned BitsInByte = 8;
 
-    // This maps 4-bit ("nibble") values into the number of 1 bits they contain.
-    static unsigned BitCountTable[16];
-
-    // Returns the number of 1 bits in the binary representation of "u".
-    template <typename T>
-    static unsigned CountBitsInIntegral(T u)
-    {
-        unsigned res = 0;
-        // We process "u" in 4-bit nibbles, hence the "*2" below.
-        for (unsigned int i = 0; i < sizeof(T) * 2; i++)
-        {
-            res += BitCountTable[u & 0xf];
-            u >>= 4;
-        }
-        return res;
-    }
-
 #ifdef DEBUG
     // This runs the "TestSuite" method for a few important instantiations of BitSet.
     static void TestSuite(CompAllocator env);
@@ -74,19 +57,6 @@ class BitSetSupport
     };
 };
 
-template <>
-FORCEINLINE unsigned BitSetSupport::CountBitsInIntegral<unsigned>(unsigned c)
-{
-    // Make sure we're 32 bit.
-    assert(sizeof(unsigned) == 4);
-    c = (c & 0x55555555) + ((c >> 1) & 0x55555555);
-    c = (c & 0x33333333) + ((c >> 2) & 0x33333333);
-    c = (c & 0x0f0f0f0f) + ((c >> 4) & 0x0f0f0f0f);
-    c = (c & 0x00ff00ff) + ((c >> 8) & 0x00ff00ff);
-    c = (c & 0x0000ffff) + ((c >> 16) & 0x0000ffff);
-    return c;
-}
-
 // A "BitSet" represents a set of integers from a "universe" [0..N-1].  This implementation assumes that "N"
 // (the "Size") is provided by the "Env" template argument type discussed below, and accessed from the Env
 // via a static method of the BitSetTraits type discussed below.  The intent of "BitSet" is that the set is

src/coreclr/jit/bitsetasshortlong.h

@@ -178,7 +178,11 @@ class BitSetOps</*BitSetType*/ BitSetShortLongRep,
     {
         if (IsShort(env))
         {
-            return BitSetSupport::CountBitsInIntegral(size_t(bs));
+#if HOST_64BIT
+            return BitOperations::PopCount(uint64_t(bs));
+#else
+            return BitOperations::PopCount(uint32_t(bs));
+#endif
         }
         else
         {
@@ -757,7 +761,11 @@ unsigned BitSetOps</*BitSetType*/ BitSetShortLongRep,
     unsigned res = 0;
     for (unsigned i = 0; i < len; i++)
     {
-        res += BitSetSupport::CountBitsInIntegral(bs[i]);
+#if HOST_64BIT
+        res += BitOperations::PopCount(uint64_t(bs[i]));
+#else
+        res += BitOperations::PopCount(uint32_t(bs[i]));
+#endif
     }
     return res;
 }

src/coreclr/jit/bitsetasuint64.h

@@ -66,7 +66,7 @@ class BitSetOps</*BitSetType*/ UINT64,
 
     static unsigned Count(Env env, UINT64 bs)
     {
-        return BitSetSupport::CountBitsInIntegral(bs);
+        return BitOperations::PopCount(bs);
     }
 
     static bool IsEmptyUnion(Env env, UINT64 bs1, UINT64 bs2)

src/coreclr/jit/hashbv.cpp

@@ -115,29 +115,6 @@ bool hashBvNode::belongsIn(indexType index)
     return true;
 }
 
-int countBitsInWord(unsigned int bits)
-{
-    // In-place adder tree: perform 16 1-bit adds, 8 2-bit adds,
-    // 4 4-bit adds, 2 8=bit adds, and 1 16-bit add.
-    bits = ((bits >> 1) & 0x55555555) + (bits & 0x55555555);
-    bits = ((bits >> 2) & 0x33333333) + (bits & 0x33333333);
-    bits = ((bits >> 4) & 0x0F0F0F0F) + (bits & 0x0F0F0F0F);
-    bits = ((bits >> 8) & 0x00FF00FF) + (bits & 0x00FF00FF);
-    bits = ((bits >> 16) & 0x0000FFFF) + (bits & 0x0000FFFF);
-    return (int)bits;
-}
-
-int countBitsInWord(uint64_t bits)
-{
-    bits = ((bits >> 1) & 0x5555555555555555) + (bits & 0x5555555555555555);
-    bits = ((bits >> 2) & 0x3333333333333333) + (bits & 0x3333333333333333);
-    bits = ((bits >> 4) & 0x0F0F0F0F0F0F0F0F) + (bits & 0x0F0F0F0F0F0F0F0F);
-    bits = ((bits >> 8) & 0x00FF00FF00FF00FF) + (bits & 0x00FF00FF00FF00FF);
-    bits = ((bits >> 16) & 0x0000FFFF0000FFFF) + (bits & 0x0000FFFF0000FFFF);
-    bits = ((bits >> 32) & 0x00000000FFFFFFFF) + (bits & 0x00000000FFFFFFFF);
-    return (int)bits;
-}
-
 int hashBvNode::countBits()
 {
     int result = 0;
@@ -146,7 +123,7 @@ int hashBvNode::countBits()
     {
         elemType bits = elements[i];
 
-        result += countBitsInWord(bits);
+        result += BitOperations::PopCount(bits);
 
         result += (int)bits;
     }

src/coreclr/jit/hashbv.h

@@ -85,34 +85,7 @@ inline int log2(int number)
 // return greatest power of 2 that is less than or equal
 inline int nearest_pow2(unsigned number)
 {
-    int result = 0;
-
-    if (number > 0xffff)
-    {
-        number >>= 16;
-        result += 16;
-    }
-    if (number > 0xff)
-    {
-        number >>= 8;
-        result += 8;
-    }
-    if (number > 0xf)
-    {
-        number >>= 4;
-        result += 4;
-    }
-    if (number > 0x3)
-    {
-        number >>= 2;
-        result += 2;
-    }
-    if (number > 0x1)
-    {
-        number >>= 1;
-        result += 1;
-    }
-    return 1 << result;
+    return 1 << BitOperations::Log2(number);
 }
 
 class hashBvNode