[APInt] Deprecate several functions

[kazu]

Summary

This patch deprecates:

• those functions that have been soft-deprecated
• count{Leading,Trailing}{Zero,Ones}
• countPopulation

Note that I've already migrated away from all known uses of these
functions.

[arsenm]

llvm/include/llvm/ADT/APInt.h

1559

I think this is a way worse name

1577

Ditto

1600

Ditto

[MaskRay]

These functions are obscure and don't seem to have much use, so I think they can just be removed. You may wait a bit for my patch to migrate away https://github.com/tensorflow/mlir-hlo/blob/master/mhlo/IR/hlo_ops.cc

[xbolva00]

llvm/include/llvm/ADT/APInt.h

1587

This function is an APInt version of the std::countr_zero.

[kazu]

Address comments.

[kazu]

llvm/include/llvm/ADT/APInt.h

1559

OK. I am not deprecating this function for now.

[kazu]

Deprecate countPopulation as before.

llvm/include/llvm/ADT/APInt.h

public:
 
   /// @}
   /// \name Value Generators
   /// @{
 
   /// Get the '0' value for the specified bit-width.
   static APInt getZero(unsigned numBits) { return APInt(numBits, 0); }
 
-  /// NOTE: This is soft-deprecated.  Please use `getZero()` instead.
+  LLVM_DEPRECATED("use getZero instead", "getZero")
   static APInt getNullValue(unsigned numBits) { return getZero(numBits); }
 
   /// Return an APInt zero bits wide.
   static APInt getZeroWidth() { return getZero(0); }
 
   /// Gets maximum unsigned value of APInt for specific bit width.
   static APInt getMaxValue(unsigned numBits) { return getAllOnes(numBits); }
 
static APInt getSignMask(unsigned BitWidth) {
     return getSignedMinValue(BitWidth);
   }
 
   /// Return an APInt of a specified width with all bits set.
   static APInt getAllOnes(unsigned numBits) {
     return APInt(numBits, WORDTYPE_MAX, true);
   }
 
-  /// NOTE: This is soft-deprecated.  Please use `getAllOnes()` instead.
+  LLVM_DEPRECATED("use getAllOnes instead", "getAllOnes")
   static APInt getAllOnesValue(unsigned numBits) { return getAllOnes(numBits); }
 
   /// Return an APInt with exactly one bit set in the result.
   static APInt getOneBitSet(unsigned numBits, unsigned BitNo) {
     APInt Res(numBits, 0);
     Res.setBit(BitNo);
     return Res;
   }
public:
   bool isAllOnes() const {
     if (BitWidth == 0)
       return true;
     if (isSingleWord())
       return U.VAL == WORDTYPE_MAX >> (APINT_BITS_PER_WORD - BitWidth);
     return countTrailingOnesSlowCase() == BitWidth;
   }
 
-  /// NOTE: This is soft-deprecated.  Please use `isAllOnes()` instead.
+  LLVM_DEPRECATED("use isAllOnes instead", "isAllOnes")
   bool isAllOnesValue() const { return isAllOnes(); }
 
   /// Determine if this value is zero, i.e. all bits are clear.
   bool isZero() const {
     if (isSingleWord())
       return U.VAL == 0;
     return countLeadingZerosSlowCase() == BitWidth;
   }
 
-  /// NOTE: This is soft-deprecated.  Please use `isZero()` instead.
+  LLVM_DEPRECATED("use isZero instead", "isZero")
   bool isNullValue() const { return isZero(); }
 
   /// Determine if this is a value of 1.
   ///
   /// This checks to see if the value of this APInt is one.
   bool isOne() const {
     if (isSingleWord())
       return U.VAL == 1;
     return countLeadingZerosSlowCase() == BitWidth - 1;
   }
 
-  /// NOTE: This is soft-deprecated.  Please use `isOne()` instead.
+  LLVM_DEPRECATED("use isOne instead", "isOne")
   bool isOneValue() const { return isOne(); }
 
   /// Determine if this is the largest unsigned value.
   ///
   /// This checks to see if the value of this APInt is the maximum unsigned
   /// value for the APInt's bit width.
   bool isMaxValue() const { return isAllOnes(); }
 
#endif
   /// function returns the same value as getActiveBits()+1. Otherwise, it
   /// returns the smallest bit width that will retain the negative value. For
   /// example, -1 can be written as 0b1 or 0xFFFFFFFFFF. 0b1 is shorter and so
   /// for -1, this function will always return 1.
   unsigned getSignificantBits() const {
     return BitWidth - getNumSignBits() + 1;
   }
 
-  /// NOTE: This is soft-deprecated.  Please use `getSignificantBits()` instead.
+  LLVM_DEPRECATED("use getSignificantBits instead", "getSignificantBits")
   unsigned getMinSignedBits() const { return getSignificantBits(); }
 
   /// Get zero extended value
   ///
   /// This method attempts to return the value of this APInt as a zero extended
   /// uint64_t. The bitwidth must be <= 64 or the value must fit within a
   /// uint64_t. Otherwise an assertion will result.
   uint64_t getZExtValue() const {
#endif
   unsigned countl_zero() const {
     if (isSingleWord()) {
       unsigned unusedBits = APINT_BITS_PER_WORD - BitWidth;
       return llvm::countl_zero(U.VAL) - unusedBits;
     }
     return countLeadingZerosSlowCase();
   }
 
   unsigned countLeadingZeros() const { return countl_zero(); }
 
   /// Count the number of leading one bits.
   ///
   /// This function is an APInt version of std::countl_one. It counts the number
   /// of ones from the most significant bit to the first zero bit.
   ///
   /// \returns 0 if the high order bit is not set, otherwise returns the number
   /// of 1 bits from the most significant to the least
   unsigned countl_one() const {
     if (isSingleWord()) {
       if (LLVM_UNLIKELY(BitWidth == 0))
         return 0;
       return llvm::countl_one(U.VAL << (APINT_BITS_PER_WORD - BitWidth));
     }
     return countLeadingOnesSlowCase();
   }
 
   unsigned countLeadingOnes() const { return countl_one(); }
 
   /// Computes the number of leading bits of this APInt that are equal to its
   /// sign bit.
   unsigned getNumSignBits() const {
     return isNegative() ? countl_one() : countl_zero();
   }
 
   /// Count the number of trailing zero bits.
   ///
-  /// This function is an APInt version of the countr_zero. It counts the number
+  /// This function is an APInt version of std::countr_zero. It counts the number
   /// of zeros from the least significant bit to the first set bit.
   ///
   /// \returns BitWidth if the value is zero, otherwise returns the number of
   /// zeros from the least significant bit to the first one bit.
   unsigned countr_zero() const {
     if (isSingleWord()) {
       unsigned TrailingZeros = llvm::countr_zero(U.VAL);
       return (TrailingZeros > BitWidth ? BitWidth : TrailingZeros);
     }
     return countTrailingZerosSlowCase();
   }
 
   unsigned countTrailingZeros() const { return countr_zero(); }
 
   /// Count the number of trailing one bits.
   ///
   /// This function is an APInt version of std::countr_one. It counts the number
   /// of ones from the least significant bit to the first zero bit.
   ///
   /// \returns BitWidth if the value is all ones, otherwise returns the number
   /// of ones from the least significant bit to the first zero bit.