[TypePromotion] Fix a hardcoded use of 32 as the size being promoted to.

[craig.topper]

Summary

At least I think that's what the 32 here is. Use RegisterBitWidth
instead.

While there replace zext with zextOrSelf to simplify the code.

[craig.topper]

Update comment as well

[samparker]

Thanks.

[dmgreen]

Do you mind making a couple of other adjustments whilst you are here? If not, I can look into them later - I apparently need to look into adjusting this same function.

llvm/lib/CodeGen/TypePromotion.cpp

368

TypePromotion::TypeSize -> TypeSize ?

370

Total.getBitWidth() -> RegisterBitWidth
Max.getBitWidth() -> TypeSize

379

Can you format this comment whilst you are here?

[craig.topper]

Simplify the code for comparing Total and Max.
Reformat comment

[dmgreen]

Thanks. I was thinking that could be simplified

llvm/lib/CodeGen/TypePromotion.cpp

 //===----- TypePromotion.cpp ----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
bool TypePromotion::isSafeWrap(Instruction *I) {
   // - The wrapping value (I) is decreasing, i.e would underflow - wrapping
   //   around zero to become a larger number than before.
   // - The wrapping instruction (I) also uses a constant.
   //
   // We can then use the two constants to calculate whether the result would
   // wrap in respect to itself in the original bitwidth. If it doesn't wrap,
   // just underflows the range, the icmp would give the same result whether the
   // result has been truncated or not. We calculate this by:
-  // - Zero extending both constants, if needed, to 32-bits.
+  // - Zero extending both constants, if needed, to RegisterBitWidth.
   // - Take the absolute value of I's constant, adding this to the icmp const.
   // - Check that this value is not out of range for small type. If it is, it
   //   means that it has underflowed enough to wrap around the icmp constant.
   //
   // For example:
   //
   // %sub = sub i8 %a, 2
   // %cmp = icmp ule i8 %sub, 254
bool TypePromotion::isSafeWrap(Instruction *I) {
   if (auto *Const = dyn_cast<ConstantInt>(CI->getOperand(0)))
     ICmpConst = Const;
   else if (auto *Const = dyn_cast<ConstantInt>(CI->getOperand(1)))
     ICmpConst = Const;
   else
     return false;
 
   // Now check that the result can't wrap on itself.
-  APInt Total = ICmpConst->getValue().getBitWidth() < 32 ?
-    ICmpConst->getValue().zext(32) : ICmpConst->getValue();
+  APInt Total = ICmpConst->getValue().zextOrSelf(RegisterBitWidth);
+  Total += OverflowConst->getValue().abs().zextOrSelf(RegisterBitWidth);
 
-  Total += OverflowConst->getValue().getBitWidth() < 32 ?
-    OverflowConst->getValue().abs().zext(32) : OverflowConst->getValue().abs();
+  APInt Max = APInt::getAllOnes(TypeSize).zextOrSelf(RegisterBitWidth);
 
-  APInt Max = APInt::getAllOnes(TypePromotion::TypeSize);
-
-  if (Total.getBitWidth() > Max.getBitWidth()) {
-    if (Total.ugt(Max.zext(Total.getBitWidth())))
-      return false;
-  } else if (Max.getBitWidth() > Total.getBitWidth()) {
-    if (Total.zext(Max.getBitWidth()).ugt(Max))
-      return false;
-  } else if (Total.ugt(Max))
+  if (Total.ugt(Max))
     return false;
 
-  LLVM_DEBUG(dbgs() << "IR Promotion: Allowing safe overflow for "
-             << *I << "\n");
+  LLVM_DEBUG(dbgs() << "IR Promotion: Allowing safe overflow for " << *I
+                    << "\n");
   SafeWrap.push_back(I);
   return true;
 }
 
 bool TypePromotion::shouldPromote(Value *V) {
   if (!isa<IntegerType>(V->getType()) || isSink(V))
     return false;