[llvm] Deprecate llvm::count{Leading,Trailing}{Zeros,Ones} and llvm::countPopulation

[kazu]

Summary

llvm/include/llvm/ADT/bit.h now has equivalent functions
forward-ported from C++20.

[kazu]

Please take a look. Thanks!

[craig.topper]

I think the title is incorrect. You're not deprecating llvm::count{pr}_{zero,one}

[kazu]

Updated the description.

[kazu]

Please take a look. Thanks!

[MaskRay]

Clang diagnostics do not use capitalization or have a trailing period (https://llvm.org/docs/CodingStandards.html#error-and-warning-messages). Conforming to that style will be better, though I do not really care whether it's capitalized or not.

[RKSimon]

llvm/unittests/Support/MathExtrasTest.cpp

66

I'm not sure what our policy is regarding test coverage - but I'd expect these to stay until we actually remove the functions being tests?

[kazu]

llvm/unittests/Support/MathExtrasTest.cpp

66

I think I have to remove these tests. Leaving them would cause warnings, so that would in turn block -Werror builds. In any event, I think the risk is pretty low; I deprecate functions after migrate their uses first.

llvm/include/llvm/Support/MathExtras.h

 } // namespace numbers
 
 /// Count number of 0's from the least significant bit to the most
 ///   stopping at the first 1.
 ///
 /// Only unsigned integral types are allowed.
 ///
 /// Returns std::numeric_limits<T>::digits on an input of 0.
-template <typename T> unsigned countTrailingZeros(T Val) {
+template <typename T>
+LLVM_DEPRECATED("Use llvm::countr_zero instead.", "llvm::countr_zero")
+unsigned countTrailingZeros(T Val) {
   static_assert(std::is_unsigned_v<T>,
                 "Only unsigned integral types are allowed.");
   return llvm::countr_zero(Val);
 }
 
 /// Count number of 0's from the most significant bit to the least
 ///   stopping at the first 1.
 ///
 /// Only unsigned integral types are allowed.
 ///
 /// Returns std::numeric_limits<T>::digits on an input of 0.
-template <typename T> unsigned countLeadingZeros(T Val) {
+template <typename T>
+LLVM_DEPRECATED("Use llvm::countl_zero instead.", "llvm::countl_zero")
+unsigned countLeadingZeros(T Val) {
   static_assert(std::is_unsigned_v<T>,
                 "Only unsigned integral types are allowed.");
   return llvm::countl_zero(Val);
 }
 
 /// Create a bitmask with the N right-most bits set to 1, and all other
 /// bits set to 0.  Only unsigned types are allowed.
 template <typename T> T maskTrailingOnes(unsigned N) {

 
 /// Count the number of ones from the most significant bit to the first
 /// zero bit.
 ///
 /// Ex. countLeadingOnes(0xFF0FFF00) == 8.
 /// Only unsigned integral types are allowed.
 ///
 /// Returns std::numeric_limits<T>::digits on an input of all ones.
-template <typename T> unsigned countLeadingOnes(T Value) {
+template <typename T>
+LLVM_DEPRECATED("Use llvm::countl_one instead.", "llvm::countl_one")
+unsigned countLeadingOnes(T Value) {
   static_assert(std::is_unsigned_v<T>,
                 "Only unsigned integral types are allowed.");
   return llvm::countl_one<T>(Value);
 }
 
 /// Count the number of ones from the least significant bit to the first
 /// zero bit.
 ///
 /// Ex. countTrailingOnes(0x00FF00FF) == 8.
 /// Only unsigned integral types are allowed.
 ///
 /// Returns std::numeric_limits<T>::digits on an input of all ones.
-template <typename T> unsigned countTrailingOnes(T Value) {
+template <typename T>
+LLVM_DEPRECATED("Use llvm::countr_one instead.", "llvm::countr_one")
+unsigned countTrailingOnes(T Value) {
   static_assert(std::is_unsigned_v<T>,
                 "Only unsigned integral types are allowed.");
   return llvm::countr_one<T>(Value);
 }
 
 /// Count the number of set bits in a value.
 /// Ex. countPopulation(0xF000F000) = 8
 /// Returns 0 if the word is zero.
 template <typename T>
+LLVM_DEPRECATED("Use llvm::popcount instead.", "llvm::popcount")
 inline unsigned countPopulation(T Value) {
   static_assert(std::is_unsigned_v<T>,
                 "Only unsigned integral types are allowed.");
   return (unsigned)llvm::popcount(Value);
 }
 
 /// Return true if the argument contains a non-empty sequence of ones with the
 /// remainder zero (32 bit version.) Ex. isShiftedMask_32(0x0000FF00U) == true.

llvm/unittests/Support/MathExtrasTest.cpp

 //===- unittests/Support/MathExtrasTest.cpp - math utils tests ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/MathExtras.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
-TEST(MathExtras, countTrailingZeros) {
-  uint8_t Z8 = 0;
-  uint16_t Z16 = 0;
-  uint32_t Z32 = 0;
-  uint64_t Z64 = 0;
-  EXPECT_EQ(8u, countTrailingZeros(Z8));
-  EXPECT_EQ(16u, countTrailingZeros(Z16));
-  EXPECT_EQ(32u, countTrailingZeros(Z32));
-  EXPECT_EQ(64u, countTrailingZeros(Z64));
-
-  uint8_t NZ8 = 42;
-  uint16_t NZ16 = 42;
-  uint32_t NZ32 = 42;
-  uint64_t NZ64 = 42;
-  EXPECT_EQ(1u, countTrailingZeros(NZ8));
-  EXPECT_EQ(1u, countTrailingZeros(NZ16));
-  EXPECT_EQ(1u, countTrailingZeros(NZ32));
-  EXPECT_EQ(1u, countTrailingZeros(NZ64));
-}
-
-TEST(MathExtras, countLeadingZeros) {
-  uint8_t Z8 = 0;
-  uint16_t Z16 = 0;
-  uint32_t Z32 = 0;
-  uint64_t Z64 = 0;
-  EXPECT_EQ(8u, countLeadingZeros(Z8));
-  EXPECT_EQ(16u, countLeadingZeros(Z16));
-  EXPECT_EQ(32u, countLeadingZeros(Z32));
-  EXPECT_EQ(64u, countLeadingZeros(Z64));
-
-  uint8_t NZ8 = 42;
-  uint16_t NZ16 = 42;
-  uint32_t NZ32 = 42;
-  uint64_t NZ64 = 42;
-  EXPECT_EQ(2u, countLeadingZeros(NZ8));
-  EXPECT_EQ(10u, countLeadingZeros(NZ16));
-  EXPECT_EQ(26u, countLeadingZeros(NZ32));
-  EXPECT_EQ(58u, countLeadingZeros(NZ64));
-
-  EXPECT_EQ(8u, countLeadingZeros(0x00F000FFu));
-  EXPECT_EQ(8u, countLeadingZeros(0x00F12345u));
-  for (unsigned i = 0; i <= 30; ++i) {
-    EXPECT_EQ(31 - i, countLeadingZeros(1u << i));
-  }
-
-  EXPECT_EQ(8u, countLeadingZeros(0x00F1234500F12345ULL));
-  EXPECT_EQ(1u, countLeadingZeros(1ULL << 62));
-  for (unsigned i = 0; i <= 62; ++i) {
-    EXPECT_EQ(63 - i, countLeadingZeros(1ULL << i));
-  }
-}
-
 TEST(MathExtras, onesMask) {
   EXPECT_EQ(0U, maskLeadingOnes<uint8_t>(0));
   EXPECT_EQ(0U, maskTrailingOnes<uint8_t>(0));
   EXPECT_EQ(0U, maskLeadingOnes<uint16_t>(0));
   EXPECT_EQ(0U, maskTrailingOnes<uint16_t>(0));
   EXPECT_EQ(0U, maskLeadingOnes<uint32_t>(0));
   EXPECT_EQ(0U, maskTrailingOnes<uint32_t>(0));
   EXPECT_EQ(0U, maskLeadingOnes<uint64_t>(0));
TEST(MathExtras, CTLog2) {
   EXPECT_EQ(CTLog2<1ULL << 10>(), 10U);
   EXPECT_EQ(CTLog2<1ULL << 11>(), 11U);
   EXPECT_EQ(CTLog2<1ULL << 12>(), 12U);
   EXPECT_EQ(CTLog2<1ULL << 13>(), 13U);
   EXPECT_EQ(CTLog2<1ULL << 14>(), 14U);
   EXPECT_EQ(CTLog2<1ULL << 15>(), 15U);
 }
 
-TEST(MathExtras, countLeadingOnes) {
-  for (int i = 30; i >= 0; --i) {
-    // Start with all ones and unset some bit.
-    EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i)));
-  }
-  for (int i = 62; i >= 0; --i) {
-    // Start with all ones and unset some bit.
-    EXPECT_EQ(63u - i, countLeadingOnes(0xFFFFFFFFFFFFFFFFULL ^ (1LL << i)));
-  }
-  for (int i = 30; i >= 0; --i) {
-    // Start with all ones and unset some bit.
-    EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i)));
-  }
-}
-
 TEST(MathExtras, FloatBits) {
   static const float kValue = 5632.34f;
   EXPECT_FLOAT_EQ(kValue, BitsToFloat(FloatToBits(kValue)));
 }
 
 TEST(MathExtras, DoubleBits) {
   static const double kValue = 87987234.983498;
   EXPECT_DOUBLE_EQ(kValue, BitsToDouble(DoubleToBits(kValue)));