[llvm] Deprecate PowerOf2Floor and ByteSwap_{16,32,64}

[kazu]

Summary

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

llvm/include/llvm/Support/MathExtras.h

constexpr inline uint64_t NextPowerOf2(uint64_t A) {
   A |= (A >> 8);
   A |= (A >> 16);
   A |= (A >> 32);
   return A + 1;
 }
 
 /// Returns the power of two which is less than or equal to the given value.
 /// Essentially, it is a floor operation across the domain of powers of two.
+LLVM_DEPRECATED("use llvm::bit_floor instead", "llvm::bit_floor")
 inline uint64_t PowerOf2Floor(uint64_t A) {
   return llvm::bit_floor(A);
 }
 
 /// Returns the power of two which is greater than or equal to the given value.
 /// Essentially, it is a ceil operation across the domain of powers of two.
 inline uint64_t PowerOf2Ceil(uint64_t A) {
   if (!A)

llvm/include/llvm/Support/SwapByteOrder.h

 #include <machine/endian.h>
 #endif
 #endif
 
 namespace llvm {
 
 /// ByteSwap_16 - This function returns a byte-swapped representation of
 /// the 16-bit argument.
+LLVM_DEPRECATED("use llvm::byteswap instead", "llvm::byteswap")
 inline uint16_t ByteSwap_16(uint16_t value) { return llvm::byteswap(value); }
 
 /// This function returns a byte-swapped representation of the 32-bit argument.
+LLVM_DEPRECATED("use llvm::byteswap instead", "llvm::byteswap")
 inline uint32_t ByteSwap_32(uint32_t value) { return llvm::byteswap(value); }
 
 /// This function returns a byte-swapped representation of the 64-bit argument.
+LLVM_DEPRECATED("use llvm::byteswap instead", "llvm::byteswap")
 inline uint64_t ByteSwap_64(uint64_t value) { return llvm::byteswap(value); }
 
 namespace sys {
 
 #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
 constexpr bool IsBigEndianHost = true;
 #else
 constexpr bool IsBigEndianHost = false;

llvm/unittests/Support/MathExtrasTest.cpp

 }
 
 TEST(MathExtras, PowerOf2Ceil) {
   EXPECT_EQ(0U, PowerOf2Ceil(0U));
   EXPECT_EQ(8U, PowerOf2Ceil(8U));
   EXPECT_EQ(8U, PowerOf2Ceil(7U));
 }
 
-TEST(MathExtras, PowerOf2Floor) {
-  EXPECT_EQ(0U, PowerOf2Floor(0U));
-  EXPECT_EQ(8U, PowerOf2Floor(8U));
-  EXPECT_EQ(4U, PowerOf2Floor(7U));
-}
-
 TEST(MathExtras, CTLog2) {
   EXPECT_EQ(CTLog2<1ULL << 0>(), 0U);
   EXPECT_EQ(CTLog2<1ULL << 1>(), 1U);
   EXPECT_EQ(CTLog2<1ULL << 2>(), 2U);
   EXPECT_EQ(CTLog2<1ULL << 3>(), 3U);
   EXPECT_EQ(CTLog2<1ULL << 4>(), 4U);
   EXPECT_EQ(CTLog2<1ULL << 5>(), 5U);
   EXPECT_EQ(CTLog2<1ULL << 6>(), 6U);

llvm/unittests/Support/SwapByteOrderTest.cpp

 #include <cstdlib>
 #include <ctime>
 using namespace llvm;
 
 #undef max
 
 namespace {
 
-TEST(ByteSwap, Swap_32) {
-  EXPECT_EQ(0x44332211u, ByteSwap_32(0x11223344));
-  EXPECT_EQ(0xDDCCBBAAu, ByteSwap_32(0xAABBCCDD));
-}
-
-TEST(ByteSwap, Swap_64) {
-  EXPECT_EQ(0x8877665544332211ULL, ByteSwap_64(0x1122334455667788LL));
-  EXPECT_EQ(0x1100FFEEDDCCBBAAULL, ByteSwap_64(0xAABBCCDDEEFF0011LL));
-}
-
 // In these first two tests all of the original_uintx values are truncated
 // except for 64. We could avoid this, but there's really no point.
 
 TEST(getSwappedBytes, UnsignedRoundTrip) {
   // The point of the bit twiddling of magic is to test with and without bits
   // in every byte.
   uint64_t value = 1;
   for (std::size_t i = 0; i <= sizeof(value); ++i) {