[TypePromotion] Fix another case for sext vs zext in promoted constant.

[craig.topper]

Summary

If the SafeWrap operation is a subtract, we negated the constant
to treat the subtract as an addition. The sext was based on the
operation being addition. So we really need to do (neg (sext (neg C)))
when promoting the constant. This is equivalent to (sext C) for
every value of C except the min signed value. For min signed value
we need to do (zext C) instead.

It turns out that the (neg C) is always less than or equal to 0. So the
original C had to be 0, positive, or min signed value. We know we need
to zext min signed value, but we can also zext 0 or positive and get the
same result as sign extending them. So we can always use a zero extend
for subtract.

Fixes PR55490.

[dmgreen]

If I haven't got this wrong, this says we could just always be zexting the constant from a sub:
https://alive2.llvm.org/ce/z/kTAyt2
https://alive2.llvm.org/ce/z/a6HHq4
That sounds like it would make simpler constants too, although I'm not sure there are any tests that show it.

What do you think? Otherwise I believe this is correct.

[craig.topper]

In D125653#3524325, @dmgreen wrote:

If I haven't got this wrong, this says we could just always be zexting the constant from a sub:
https://alive2.llvm.org/ce/z/kTAyt2
https://alive2.llvm.org/ce/z/a6HHq4
That sounds like it would make simpler constants too, although I'm not sure there are any tests that show it.

What do you think? Otherwise I believe this is correct.

Since the pre-condition is -C1 <=s 0, then for all values of C1 except 0x80, the sign bit of C1 is 0. And the 0x80 case is the bug that requires zext. 0x80 can only occur for one of the two proofs since the first proof requires -C1 >s C2 which is never true for C1==0x80. I think all this means that yes we could use zext for sub, but I don't think it will generate better constants.

[craig.topper]

Use zext for Subtract always.

[dmgreen]

OK thanks. LGTM

llvm/lib/CodeGen/TypePromotion.cpp

if (Sinks.count(I))
       continue;
 
     for (unsigned i = 0, e = I->getNumOperands(); i < e; ++i) {
       Value *Op = I->getOperand(i);
       if ((Op->getType() == ExtTy) || !isa<IntegerType>(Op->getType()))
         continue;
 
       if (auto *Const = dyn_cast<ConstantInt>(Op)) {
-        Constant *NewConst = (SafeWrap.contains(I) && i == 1)
+        // For subtract, we don't need to sext the constant. We only put it in
+        // SafeWrap because SafeWrap.size() is used elsewhere.
+        Constant *NewConst = (SafeWrap.contains(I) && i == 1 &&
+                              I->getOpcode() != Instruction::Sub)
                                  ? ConstantExpr::getSExt(Const, ExtTy)
                                  : ConstantExpr::getZExt(Const, ExtTy);
         I->setOperand(i, NewConst);
       } else if (isa<UndefValue>(Op))
         I->setOperand(i, ConstantInt::get(ExtTy, 0));
     }
 
     // Mutate the result type, unless this is an icmp or switch.

llvm/test/Transforms/TypePromotion/ARM/icmps.ll

 ; CHECK-NEXT:    [[TMP3:%.*]] = select i1 [[TMP2]], i32 1, i32 0
 ; CHECK-NEXT:    ret i32 [[TMP3]]
 ;
   %1 = sub i8 -66, 0
   %2 = icmp ugt i8 -31, %1
   %3 = select i1 %2, i32 1, i32 0
   ret i32 %3
 }
+
+define i1 @pr55490() {
+; CHECK-LABEL: @pr55490(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 10, 8
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp ult i32 [[TMP1]], 3
+; CHECK-NEXT:    ret i1 [[TMP2]]
+;
+  %1 = sub i4 -6, -8
+  %2 = icmp ult i4 %1, 3
+  ret i1 %2
+}