[InstCombine] fold signed absolute diff patterns

[spatel]

Summary

This overlaps partially with the codegen patch D144789. This needs nsw for correctness, and I'm not sure if there's an unsigned equivalent:
https://alive2.llvm.org/ce/z/ErmQ-9

This is obviously an improvement in IR, and it looks like a codegen win for all targets and data types that I sampled.

The 'nabs' case is not as clean because I think it would require clearing nsw from the subtract to be correct, so that's left as a potential follow-up (and seems less likely to occur in real code).

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

970

It also works for nuw: https://alive2.llvm.org/ce/z/YfWtvG (either op can be either nsw/nuw)

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

970

Good point - the icmp+select filters out the poison either way. But if we match nuw, we can't propagate it:
https://alive2.llvm.org/ce/z/2b5jiJ

So if the sub has >1 use, we'll need to clear the nuw on the existing sub or create a new instruction with nsw set. I don't think it's safe to alter the flags on the existing instruction if there's more than one use.

This might overlap with changes needed to support the "nabs" pattern that I mentioned in the patch description. Ok, if we make it a TODO for this patch? I'll add more tests either way.

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

970

"Alter" in that sentence should have been "set". We can always clear no-wrap flags safely, but we can't set them without some context.

[RKSimon]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

970

A TODO should be fine - thanks

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

970

On 2nd thought, this patch has a bug if the subtracts have both "nsw" and "nuw" set. So we need to do the more complicated logic in this step anyway. :)

[spatel]

Patch updated:

1. Match any pair of no-wrap subtracts.
2. But only propagate "nsw" with restrictions.

I added tests to try to make sure we are covering all of the variations and confirmed those and several others with Alive2.

[RKSimon]

LGTM

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

980

Why does one-use allow it to be nsw?

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

980

If there's one use of the subtract (no other use than the use we are about to replace), then we know that the sub is "nsw" in this context even if it was "nuw" before:
https://alive2.llvm.org/ce/z/cmSzrG

That's what we are verifying in the abs_diff_signed_sgt_nuw test.

But if there's another use, then we can't add "nsw" to the existing instruction because it may not be safe in the other user's context:
https://alive2.llvm.org/ce/z/mio8xf

This is more complicated than the usual no-wrap propagation. I can add text like this to the code comment if this helped to explain it.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

if (Pred == ICmpInst::ICMP_ULT &&
     // ((X + Y) u< X) ? -1 : (X + Y) --> uadd.sat(X, Y)
     // ((X + Y) u< Y) ? -1 : (X + Y) --> uadd.sat(X, Y)
     return Builder.CreateBinaryIntrinsic(Intrinsic::uadd_sat, Cmp1, Y);
   }
 
   return nullptr;
 }
 
+/// Try to match patterns with select and subtract as absolute difference.
+static Value *foldAbsDiff(ICmpInst *Cmp, Value *TVal, Value *FVal,
+                          InstCombiner::BuilderTy &Builder) {
+  auto *TI = dyn_cast<Instruction>(TVal);
+  auto *FI = dyn_cast<Instruction>(FVal);
+  if (!TI || !FI)
+    return nullptr;
+
+  // Normalize predicate to gt/lt rather than ge/le.
+  ICmpInst::Predicate Pred = Cmp->getStrictPredicate();
+  Value *A = Cmp->getOperand(0);
+  Value *B = Cmp->getOperand(1);
+
+  // Normalize "A - B" as the true value of the select.
+  if (match(FI, m_Sub(m_Specific(A), m_Specific(B)))) {
+    std::swap(FI, TI);
+    Pred = ICmpInst::getSwappedPredicate(Pred);
+  }
+
+  // With any pair of no-wrap subtracts:
+  // (A > B) ? (A - B) : (B - A) --> abs(A - B)
+  if (Pred == CmpInst::ICMP_SGT &&
+      match(TI, m_Sub(m_Specific(A), m_Specific(B))) &&
+      match(FI, m_Sub(m_Specific(B), m_Specific(A))) &&
+      (TI->hasNoSignedWrap() || TI->hasNoUnsignedWrap()) &&
+      (FI->hasNoSignedWrap() || FI->hasNoUnsignedWrap())) {
+    // The remaining subtract is not "nuw" any more.
+    // If there's one use of the subtract (no other use than the use we are
+    // about to replace), then we know that the sub is "nsw" in this context
+    // even if it was only "nuw" before. If there's another use, then we can't
+    // add "nsw" to the existing instruction because it may not be safe in the
+    // other user's context.
+    TI->setHasNoUnsignedWrap(false);
+    if (!TI->hasNoSignedWrap())
+      TI->setHasNoSignedWrap(TI->hasOneUse());
+    return Builder.CreateBinaryIntrinsic(Intrinsic::abs, TI, Builder.getTrue());
+  }
+
+  return nullptr;
+}
+
 /// Fold the following code sequence:
 /// \code
 ///   int a = ctlz(x & -x);
 //    x ? 31 - a : a;
 /// \code
 ///
 /// into:
 ///   cttz(x)
if (Value *V = foldSelectCttzCtlz(ICI, TrueVal, FalseVal, Builder))
     return replaceInstUsesWith(SI, V);
 
   if (Value *V = canonicalizeSaturatedSubtract(ICI, TrueVal, FalseVal, Builder))
     return replaceInstUsesWith(SI, V);
 
   if (Value *V = canonicalizeSaturatedAdd(ICI, TrueVal, FalseVal, Builder))
     return replaceInstUsesWith(SI, V);
 
+  if (Value *V = foldAbsDiff(ICI, TrueVal, FalseVal, Builder))
+    return replaceInstUsesWith(SI, V);
+
   return Changed ? &SI : nullptr;
 }
 
 /// SI is a select whose condition is a PHI node (but the two may be in
 /// different blocks). See if the true/false values (V) are live in all of the
 /// predecessor blocks of the PHI. For example, cases like this can't be mapped:
 ///
 ///   X = phi [ C1, BB1], [C2, BB2]

llvm/test/Transforms/InstCombine/abs-1.ll

;
   %c = icmp slt i8 %x, 0
   call void @extra_use_i1(i1 %c)
   %n = sub i8 0, %x
   call void @extra_use(i8 %n)
   %s = select i1 %c, i8 %x, i8 %n
   ret i8 %s
 }
 
+; TODO: negate-of-abs-diff
+
 define i32 @nabs_diff_signed_slt(i32 %a, i32 %b) {
 ; CHECK-LABEL: @nabs_diff_signed_slt(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i32 [[B]], [[A]]
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[SUB_AB]], i32 [[SUB_BA]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %cmp = icmp slt i32 %a, %b
   %sub_ba = sub nsw i32 %b, %a
   %sub_ab = sub nsw i32 %a, %b
   %cond = select i1 %cmp, i32 %sub_ab, i32 %sub_ba
   ret i32 %cond
 }
 
+; TODO: negate-of-abs-diff
+
 define <2 x i8> @nabs_diff_signed_sle(<2 x i8> %a, <2 x i8> %b) {
 ; CHECK-LABEL: @nabs_diff_signed_sle(
 ; CHECK-NEXT:    [[CMP_NOT:%.*]] = icmp sgt <2 x i8> [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw <2 x i8> [[B]], [[A]]
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw <2 x i8> [[A]], [[B]]
 ; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP_NOT]], <2 x i8> [[SUB_BA]], <2 x i8> [[SUB_AB]]
 ; CHECK-NEXT:    ret <2 x i8> [[COND]]
 ;
   %cmp = icmp sle <2 x i8> %a, %b
   %sub_ba = sub nsw <2 x i8> %b, %a
   %sub_ab = sub nsw <2 x i8> %a, %b
   %cond = select <2 x i1> %cmp, <2 x i8> %sub_ab, <2 x i8> %sub_ba
   ret <2 x i8> %cond
 }
 
 define i8 @abs_diff_signed_sgt(i8 %a, i8 %b) {
 ; CHECK-LABEL: @abs_diff_signed_sgt(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i8 [[B]], [[A]]
-; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i8 [[A]], [[B]]
+; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_AB]])
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i8 [[SUB_AB]], i8 [[SUB_BA]]
+; CHECK-NEXT:    [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
 ; CHECK-NEXT:    ret i8 [[COND]]
 ;
   %cmp = icmp sgt i8 %a, %b
   %sub_ba = sub nsw i8 %b, %a
   %sub_ab = sub nsw i8 %a, %b
   call void @extra_use(i8 %sub_ab)
   %cond = select i1 %cmp, i8 %sub_ab, i8 %sub_ba
   ret i8 %cond
 }
 
 define i8 @abs_diff_signed_sge(i8 %a, i8 %b) {
 ; CHECK-LABEL: @abs_diff_signed_sge(
-; CHECK-NEXT:    [[CMP_NOT:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i8 [[B]], [[A]]
+; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i8 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_BA]])
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i8 [[A]], [[B]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_AB]])
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP_NOT]], i8 [[SUB_BA]], i8 [[SUB_AB]]
+; CHECK-NEXT:    [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
 ; CHECK-NEXT:    ret i8 [[COND]]
 ;
   %cmp = icmp sge i8 %a, %b
   %sub_ba = sub nsw i8 %b, %a
   call void @extra_use(i8 %sub_ba)
   %sub_ab = sub nsw i8 %a, %b
   call void @extra_use(i8 %sub_ab)
   %cond = select i1 %cmp, i8 %sub_ab, i8 %sub_ba
   ret i8 %cond
 }
 
+; negative test - need nsw
+
 define i32 @abs_diff_signed_slt_no_nsw(i32 %a, i32 %b) {
 ; CHECK-LABEL: @abs_diff_signed_slt_no_nsw(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[SUB_BA:%.*]] = sub i32 [[B]], [[A]]
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[SUB_AB]], i32 [[SUB_BA]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %cmp = icmp slt i32 %a, %b
   %sub_ba = sub i32 %b, %a
   %sub_ab = sub i32 %a, %b
   %cond = select i1 %cmp, i32 %sub_ab, i32 %sub_ba
   ret i32 %cond
 }
 
+; bonus nuw - it's fine to match the pattern, but nuw can't propagate
+
 define i8 @abs_diff_signed_sgt_nsw_nuw(i8 %a, i8 %b) {
 ; CHECK-LABEL: @abs_diff_signed_sgt_nsw_nuw(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nuw nsw i8 [[B]], [[A]]
-; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nuw nsw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i8 [[SUB_AB]], i8 [[SUB_BA]]
+; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
 ; CHECK-NEXT:    ret i8 [[COND]]
 ;
   %cmp = icmp sgt i8 %a, %b
   %sub_ba = sub nsw nuw i8 %b, %a
   %sub_ab = sub nsw nuw i8 %a, %b
   %cond = select i1 %cmp, i8 %sub_ab, i8 %sub_ba
   ret i8 %cond
 }
 
+; this is absolute diff, but nuw can't propagate and nsw can be set.
+
 define i8 @abs_diff_signed_sgt_nuw(i8 %a, i8 %b) {
 ; CHECK-LABEL: @abs_diff_signed_sgt_nuw(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nuw i8 [[B]], [[A]]
-; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nuw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i8 [[SUB_AB]], i8 [[SUB_BA]]
+; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
 ; CHECK-NEXT:    ret i8 [[COND]]
 ;
   %cmp = icmp sgt i8 %a, %b
   %sub_ba = sub nuw i8 %b, %a
   %sub_ab = sub nuw i8 %a, %b
   %cond = select i1 %cmp, i8 %sub_ab, i8 %sub_ba
   ret i8 %cond
 }
 
+; same as above
+
 define i8 @abs_diff_signed_sgt_nuw_extra_use1(i8 %a, i8 %b) {
 ; CHECK-LABEL: @abs_diff_signed_sgt_nuw_extra_use1(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nuw i8 [[B]], [[A]]
+; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nuw i8 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_BA]])
-; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nuw i8 [[A]], [[B]]
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i8 [[SUB_AB]], i8 [[SUB_BA]]
+; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i8 [[A]], [[B]]
+; CHECK-NEXT:    [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
 ; CHECK-NEXT:    ret i8 [[COND]]
 ;
   %cmp = icmp sgt i8 %a, %b
   %sub_ba = sub nuw i8 %b, %a
   call void @extra_use(i8 %sub_ba)
   %sub_ab = sub nuw i8 %a, %b
   %cond = select i1 %cmp, i8 %sub_ab, i8 %sub_ba
   ret i8 %cond
 }
 
+; nuw can't propagate, and the extra use prevents applying nsw
+
 define i8 @abs_diff_signed_sgt_nuw_extra_use2(i8 %a, i8 %b) {
 ; CHECK-LABEL: @abs_diff_signed_sgt_nuw_extra_use2(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nuw i8 [[B]], [[A]]
-; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nuw i8 [[A]], [[B]]
+; CHECK-NEXT:    [[SUB_AB:%.*]] = sub i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_AB]])
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i8 [[SUB_AB]], i8 [[SUB_BA]]
+; CHECK-NEXT:    [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
 ; CHECK-NEXT:    ret i8 [[COND]]
 ;
   %cmp = icmp sgt i8 %a, %b
   %sub_ba = sub nuw i8 %b, %a
   %sub_ab = sub nuw i8 %a, %b
   call void @extra_use(i8 %sub_ab)
   %cond = select i1 %cmp, i8 %sub_ab, i8 %sub_ba
   ret i8 %cond
 }
 
+; same as above
+
 define i8 @abs_diff_signed_sgt_nuw_extra_use3(i8 %a, i8 %b) {
 ; CHECK-LABEL: @abs_diff_signed_sgt_nuw_extra_use3(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nuw i8 [[B]], [[A]]
+; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nuw i8 [[B:%.*]], [[A:%.*]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_BA]])
-; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nuw i8 [[A]], [[B]]
+; CHECK-NEXT:    [[SUB_AB:%.*]] = sub i8 [[A]], [[B]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_AB]])
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i8 [[SUB_AB]], i8 [[SUB_BA]]
+; CHECK-NEXT:    [[COND:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB_AB]], i1 true)
 ; CHECK-NEXT:    ret i8 [[COND]]
 ;
   %cmp = icmp sgt i8 %a, %b
   %sub_ba = sub nuw i8 %b, %a
   call void @extra_use(i8 %sub_ba)
   %sub_ab = sub nuw i8 %a, %b
   call void @extra_use(i8 %sub_ab)
   %cond = select i1 %cmp, i8 %sub_ab, i8 %sub_ba
   ret i8 %cond
 }
 
+; negative test - wrong predicate
+
 define i32 @abs_diff_signed_slt_swap_wrong_pred1(i32 %a, i32 %b) {
 ; CHECK-LABEL: @abs_diff_signed_slt_swap_wrong_pred1(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i32 [[B]], [[A]]
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[SUB_BA]], i32 [[SUB_AB]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %cmp = icmp eq i32 %a, %b
   %sub_ba = sub nsw i32 %b, %a
   %sub_ab = sub nsw i32 %a, %b
   %cond = select i1 %cmp, i32 %sub_ba, i32 %sub_ab
   ret i32 %cond
 }
 
+; negative test - wrong predicate
+
 define i32 @abs_diff_signed_slt_swap_wrong_pred2(i32 %a, i32 %b) {
 ; CHECK-LABEL: @abs_diff_signed_slt_swap_wrong_pred2(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i32 [[B]], [[A]]
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[SUB_BA]], i32 [[SUB_AB]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %cmp = icmp ult i32 %a, %b
   %sub_ba = sub nsw i32 %b, %a
   %sub_ab = sub nsw i32 %a, %b
   %cond = select i1 %cmp, i32 %sub_ba, i32 %sub_ab
   ret i32 %cond
 }
 
+; negative test - need common operands
+
 define i32 @abs_diff_signed_slt_swap_wrong_op(i32 %a, i32 %b, i32 %z) {
 ; CHECK-LABEL: @abs_diff_signed_slt_swap_wrong_op(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[SUB_BZ:%.*]] = sub nsw i32 [[B]], [[Z:%.*]]
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[SUB_BZ]], i32 [[SUB_AB]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %cmp = icmp eq i32 %a, %b
   %sub_bz = sub nsw i32 %b, %z
   %sub_ab = sub nsw i32 %a, %b
   %cond = select i1 %cmp, i32 %sub_bz, i32 %sub_ab
   ret i32 %cond
 }
 
 define i32 @abs_diff_signed_slt_swap(i32 %a, i32 %b) {
 ; CHECK-LABEL: @abs_diff_signed_slt_swap(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i32 [[B]], [[A]]
-; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i32 [[A]], [[B]]
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[SUB_BA]], i32 [[SUB_AB]]
+; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[COND:%.*]] = call i32 @llvm.abs.i32(i32 [[SUB_AB]], i1 true)
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %cmp = icmp slt i32 %a, %b
   %sub_ba = sub nsw i32 %b, %a
   %sub_ab = sub nsw i32 %a, %b
   %cond = select i1 %cmp, i32 %sub_ba, i32 %sub_ab
   ret i32 %cond
 }
 
 define <2 x i8> @abs_diff_signed_sle_swap(<2 x i8> %a, <2 x i8> %b) {
 ; CHECK-LABEL: @abs_diff_signed_sle_swap(
-; CHECK-NEXT:    [[CMP_NOT:%.*]] = icmp sgt <2 x i8> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw <2 x i8> [[B]], [[A]]
-; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw <2 x i8> [[A]], [[B]]
-; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP_NOT]], <2 x i8> [[SUB_AB]], <2 x i8> [[SUB_BA]]
+; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw <2 x i8> [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[COND:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[SUB_AB]], i1 true)
 ; CHECK-NEXT:    ret <2 x i8> [[COND]]
 ;
   %cmp = icmp sle <2 x i8> %a, %b
   %sub_ba = sub nsw <2 x i8> %b, %a
   %sub_ab = sub nsw <2 x i8> %a, %b
   %cond = select <2 x i1> %cmp, <2 x i8> %sub_ba, <2 x i8> %sub_ab
   ret <2 x i8> %cond
 }
 
+; TODO: negate-of-abs-diff
+
 define i8 @nabs_diff_signed_sgt_swap(i8 %a, i8 %b) {
 ; CHECK-LABEL: @nabs_diff_signed_sgt_swap(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i8 [[B]], [[A]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_BA]])
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i8 [[SUB_BA]], i8 [[SUB_AB]]
 ; CHECK-NEXT:    ret i8 [[COND]]
 ;
   %cmp = icmp sgt i8 %a, %b
   %sub_ba = sub nsw i8 %b, %a
   call void @extra_use(i8 %sub_ba)
   %sub_ab = sub nsw i8 %a, %b
   %cond = select i1 %cmp, i8 %sub_ba, i8 %sub_ab
   ret i8 %cond
 }
 
+; TODO: negate-of-abs-diff, but too many uses?
+
 define i8 @nabs_diff_signed_sge_swap(i8 %a, i8 %b) {
 ; CHECK-LABEL: @nabs_diff_signed_sge_swap(
 ; CHECK-NEXT:    [[CMP_NOT:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i8 [[B]], [[A]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_BA]])
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub nsw i8 [[A]], [[B]]
 ; CHECK-NEXT:    call void @extra_use(i8 [[SUB_AB]])
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP_NOT]], i8 [[SUB_AB]], i8 [[SUB_BA]]
 ; CHECK-NEXT:    ret i8 [[COND]]
 ;
   %cmp = icmp sge i8 %a, %b
   %sub_ba = sub nsw i8 %b, %a
   call void @extra_use(i8 %sub_ba)
   %sub_ab = sub nsw i8 %a, %b
   call void @extra_use(i8 %sub_ab)
   %cond = select i1 %cmp, i8 %sub_ba, i8 %sub_ab
   ret i8 %cond
 }
 
+; negative test - need nsw
+
 define i32 @abs_diff_signed_slt_no_nsw_swap(i32 %a, i32 %b) {
 ; CHECK-LABEL: @abs_diff_signed_slt_no_nsw_swap(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[SUB_BA:%.*]] = sub nsw i32 [[B]], [[A]]
 ; CHECK-NEXT:    [[SUB_AB:%.*]] = sub i32 [[A]], [[B]]
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[SUB_BA]], i32 [[SUB_AB]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %cmp = icmp slt i32 %a, %b
   %sub_ba = sub nsw i32 %b, %a
   %sub_ab = sub i32 %a, %b
   %cond = select i1 %cmp, i32 %sub_ba, i32 %sub_ab
   ret i32 %cond
 }