[NFC] Replace -1U{LL} expressions with appropriate *_MAX macros in Support library.

[pavelkopyl]

Summary

This makes a code a bit more clear and also gets rid of C4146 warning
on MSVC compiler:
'unary minus operator applied to unsigned type, result still unsigned'.

In case uint64_t variable is initialized or compared against -1U expression,
which corresponds to 32-bit constant, UINT_MAX macro is used to preserve
NFC semantics; -1ULL is replaced with UINT64_MAX.

[dblaikie]

Mixed feelings - if the code is valid/does what the developer intended, and the MSVC warning is just giving false positives/being too chatty, then we should probably disable the MSVC warning.

Equally, this does seem more readable, at the cost of including another header - but I guess there aren't too many TUs that don't include climits somewhere along the way.

I'm OK with this, but also open to hearing other people's perspectives.

[craig.topper]

llvm/include/llvm/Support/BlockFrequency.h

30

Why not UINT64_MAX?

[pavelkopyl]

In D143942#4124074, @dblaikie wrote:

Mixed feelings - if the code is valid/does what the developer intended, and the MSVC warning is just giving false positives/being too chatty, then we should probably disable the MSVC warning.

Equally, this does seem more readable, at the cost of including another header - but I guess there aren't too many TUs that don't include climits somewhere along the way.

I'm OK with this, but also open to hearing other people's perspectives.

Actually, this warning is already suppressed in mainline, but we have a bit customized build where it would more desirable to "fix" it.

[pavelkopyl]

llvm/include/llvm/Support/BlockFrequency.h

30

Sure, that's possible (and <climits> is not required in this case), but I just wanted to preserve ULL type of the constant. Yep, probably UINT64_MAX looks more natural taking into account the destination type.

[pavelkopyl]

Replace ULLONG_MAX with UINT64_MAX.

[craig.topper]

LGTM

llvm/include/llvm/Support/BlockFrequency.h

 // This class represents Block Frequency as a 64-bit value.
 class BlockFrequency {
   uint64_t Frequency;
 
 public:
   BlockFrequency(uint64_t Freq = 0) : Frequency(Freq) { }
 
   /// Returns the maximum possible frequency, the saturation value.
-  static uint64_t getMaxFrequency() { return -1ULL; }
+  static uint64_t getMaxFrequency() { return UINT64_MAX; }
 
   /// Returns the frequency as a fixpoint number scaled by the entry
   /// frequency.
   uint64_t getFrequency() const { return Frequency; }
 
   /// Multiplies with a branch probability. The computation will never
   /// overflow.
   BlockFrequency &operator*=(BranchProbability Prob);

llvm/include/llvm/Support/LEB128.h

if ((Shift >= 64 && Slice != (Value < 0 ? 0x7f : 0x00)) ||
       return 0;
     }
     Value |= Slice << Shift;
     Shift += 7;
     ++p;
   } while (Byte >= 128);
   // Sign extend negative numbers if needed.
   if (Shift < 64 && (Byte & 0x40))
-    Value |= (-1ULL) << Shift;
+    Value |= UINT64_MAX << Shift;
   if (n)
     *n = (unsigned)(p - orig_p);
   return Value;
 }
 
 /// Utility function to get the size of the ULEB128-encoded value.
 extern unsigned getULEB128Size(uint64_t Value);
 
 /// Utility function to get the size of the SLEB128-encoded value.
 extern unsigned getSLEB128Size(int64_t Value);
 
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_LEB128_H

llvm/lib/Support/APFloat.cpp

trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
 
   if (p == end)
     return createError("Invalid trailing hexadecimal fraction!");
 
   hexDigit = hexDigitValue(*p);
 
   /* If we ran off the end it is exactly zero or one-half, otherwise
      a little more.  */
-  if (hexDigit == -1U)
+  if (hexDigit == UINT_MAX)
     return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
   else
     return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
 }
 
 /* Return the fraction lost were a bignum truncated losing the least
    significant BITS bits.  */
 static lostFraction
 lostFractionThroughTruncation(const APFloatBase::integerPart *parts,
                               unsigned int partCount,
                               unsigned int bits)
 {
   unsigned int lsb;
 
   lsb = APInt::tcLSB(parts, partCount);
 
-  /* Note this is guaranteed true if bits == 0, or LSB == -1U.  */
+  /* Note this is guaranteed true if bits == 0, or LSB == UINT_MAX.  */
   if (bits <= lsb)
     return lfExactlyZero;
   if (bits == lsb + 1)
     return lfExactlyHalf;
   if (bits <= partCount * APFloatBase::integerPartWidth &&
       APInt::tcExtractBit(parts, bits - 1))
     return lfMoreThanHalf;
 
while (p != end) {
     if (*p == '.') {
       if (dot != end)
         return createError("String contains multiple dots");
       dot = p++;
       continue;
     }
 
     hex_value = hexDigitValue(*p);
-    if (hex_value == -1U)
+    if (hex_value == UINT_MAX)
       break;
 
     p++;
 
     // Store the number while we have space.
     if (bitPos) {
       bitPos -= 4;
       hex_value <<= bitPos % integerPartWidth;

llvm/lib/Support/APInt.cpp

if (radix == 16 || radix == 36) {
 
     radix = 10;
   }
 
   r = cdigit - '0';
   if (r < radix)
     return r;
 
-  return -1U;
+  return UINT_MAX;
 }
 
 
 void APInt::initSlowCase(uint64_t val, bool isSigned) {
   U.pVal = getClearedMemory(getNumWords());
   U.pVal[0] = val;
   if (isSigned && int64_t(val) < 0)
     for (unsigned i = 1; i < getNumWords(); ++i)

 }
 
 /// Clears the given bit of a bignum.
 void APInt::tcClearBit(WordType *parts, unsigned bit) {
   parts[whichWord(bit)] &= ~maskBit(bit);
 }
 
 /// Returns the bit number of the least significant set bit of a number.  If the
-/// input number has no bits set -1U is returned.
+/// input number has no bits set UINT_MAX is returned.
 unsigned APInt::tcLSB(const WordType *parts, unsigned n) {
   for (unsigned i = 0; i < n; i++) {
     if (parts[i] != 0) {
       unsigned lsb = llvm::countr_zero(parts[i]);
       return lsb + i * APINT_BITS_PER_WORD;
     }
   }
 
-  return -1U;
+  return UINT_MAX;
 }
 
 /// Returns the bit number of the most significant set bit of a number.
-/// If the input number has no bits set -1U is returned.
+/// If the input number has no bits set UINT_MAX is returned.
 unsigned APInt::tcMSB(const WordType *parts, unsigned n) {
   do {
     --n;
 
     if (parts[n] != 0) {
       static_assert(sizeof(parts[n]) <= sizeof(uint64_t));
       unsigned msb = llvm::Log2_64(parts[n]);
 
       return msb + n * APINT_BITS_PER_WORD;
     }
   } while (n);
 
-  return -1U;
+  return UINT_MAX;
 }
 
 /// Copy the bit vector of width srcBITS from SRC, starting at bit srcLSB, to
 /// DST, of dstCOUNT parts, such that the bit srcLSB becomes the least
 /// significant bit of DST.  All high bits above srcBITS in DST are zero-filled.
 /// */
 void
 APInt::tcExtract(WordType *dst, unsigned dstCount, const WordType *src,