[InstCombine] canonicalize abs pattern

[shchenz]

Summary

two more abs pattern and canonicalize abs pattern.
This patch handle two more pattern:
1:

define i32 @abs_canonical_6(i32 %a, i32 %b) {
  %tmp1 = sub i32 %a, %b
  %cmp = icmp sgt i32 %tmp1, -1
  %tmp2 = sub i32 %b, %a
  %abs = select i1 %cmp, i32 %tmp1, i32 %tmp2
  ret i32 %abs
}

this should be |a-b|.

2:

define <2 x i8> @abs_canonical_7(<2 x i8> %a, <2 x i8 > %b) {
  %tmp1 = sub <2 x i8> %a, %b
  %cmp = icmp sgt <2 x i8> %tmp1, <i8 -1, i8 -1>
  %tmp2 = sub <2 x i8> %b, %a
  %abs = select <2 x i1> %cmp, <2 x i8> %tmp1, <2 x i8> %tmp2
  ret <2 x i8> %abs
}

this should be |a - b| for vector type.

3:

define i32 @abs_canonical_8(i32 %a) {
; CHECK-LABEL: @abs_canonical_8(
; CHECK-NEXT:    [[TMP:%.*]] = sub i32 0, [[A:%.*]]
; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP]], 0
; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[A]], i32 [[TMP]]
; CHECK-NEXT:    ret i32 [[ABS]]
;
  %tmp = sub i32 0, %a
  %cmp = icmp slt i32 %tmp, 0
  %abs = select i1 %cmp, i32 %a, i32 %tmp
  ret i32 %abs
}

this should be |-a| -> |a|
Also add test cases for -|a-b|(i32 and vector), -|-a|(-|a|)

[craig.topper]

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

17528 ↗

(On Diff #153437)

Just declare this local to the 2 blocks that need since it doesn't live outside of them.

17530 ↗

(On Diff #153437)

You probably don't need the GE/LE checks. We should be canonicalizing those away by altering the constant.

[shchenz]

fix Craig's comments

[spatel]

For min/max, we made value tracking (matchSelectPattern) recognize more patterns:
https://reviews.llvm.org/rL286776

And then we canonicalized the IR to the most recognizable form (where the cmp operands match the select operands):
https://reviews.llvm.org/rL295758

I think that's a better solution than adding more pattern matching to the DAG. For example, this isn't going to help vector code?

[shchenz]

@spatel Hi Sanjay, thanks for your comments. I will look into it.

[spatel]

In D48754#1149226, @shchenz wrote:

@spatel Hi Sanjay, thanks for your comments. I will look into it.

Thanks - here are recent patches for abs IR canonicalization:
D47076
rL334137

...so you want modify/add the pattern that has a 'sub' with something similar. We haven't made ValueTracking changes corresponding to those (but probably should). There's also an open question about creating ISD::ABS nodes directly in SelectionDAGBuilder. I think it's just an oversight that we use matchSelectPattern to create min/max there, but not abs.

[RKSimon]

In D48754#1149389, @spatel wrote:

There's also an open question about creating ISD::ABS nodes directly in SelectionDAGBuilder. I think it's just an oversight that we use matchSelectPattern to create min/max there, but not abs.

For reference, this was raised in PR37743

[shchenz]

@spatel Hi Sanjay, thanks for your comments. After investigation, I split this task into three parts:
1: find more abs pattern in matchSelectPattern and do canonicalization for abs/nabs pattern. (cmp + select). This is what this patch doing.
2: recognize ISD::ABS in selectionDAGBuilder to leverage platform abs instruction. (https://bugs.llvm.org/show_bug.cgi?id=36036). This will be done in next patch.
3: if no platform abs instructions, recognize canonicalized abs pattern (cmp + select) to shift + add + xor in DAGCombiner. This will be done in third patch.

What do you think about above proposal? And could you please help to do another review for this patch? Thanks.

[spatel]

In D48754#1151712, @shchenz wrote:

@spatel Hi Sanjay, thanks for your comments. After investigation, I split this task into three parts:
1: find more abs pattern in matchSelectPattern and do canonicalization for abs/nabs pattern. (cmp + select). This is what this patch doing.
2: recognize ISD::ABS in selectionDAGBuilder to leverage platform abs instruction. (https://bugs.llvm.org/show_bug.cgi?id=36036). This will be done in next patch.
3: if no platform abs instructions, recognize canonicalized abs pattern (cmp + select) to shift + add + xor in DAGCombiner. This will be done in third patch.

What do you think about above proposal? And could you please help to do another review for this patch? Thanks.

Yes, this sounds like a good plan to me.

[spatel]

llvm/include/llvm/Analysis/ValueTracking.h

104–105 ↗

(On Diff #154047)

Doesn't "complement" mean bitwise-not? I think this should be called "isKnownNegation" unless I'm mixing up the terminology.

Nit: add a period at end of comment.

llvm/lib/Analysis/ValueTracking.cpp

4506 ↗

(On Diff #154047)

Don't repeat the comment from the header file.

4508–4509 ↗

(On Diff #154047)

Make that an assert? Other functions in this file just assume that the parameters are valid. Ideally, we'd change everything to references instead of pointers...

4515 ↗

(On Diff #154047)

The comments don't match the code. The parameters to this function should be named X and Y, and these local values should be named A and B?

4516 ↗

(On Diff #154047)

Don't initialize these to nullptr. They should not be read if they are uninitialized, so explicitly initializing them removes a chance to produce a warning for that situation.

4521 ↗

(On Diff #154047)

Remove the TODO or specify a pattern that you know should be added later.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

815–817 ↗

(On Diff #154047)

We should check the negated value in the select here. If it is not m_Neg(), then we should create a new sub (neg) in the canonical form.

If you would prefer to make that a separate patch, then please add a 'TODO' comment here.

826 ↗

(On Diff #154047)

Formatting: goes over 80-columns.

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

119–123 ↗

(On Diff #154047)

Please commit all new tests to trunk with the current output. Then rebase this patch so we see only the diffs.

[shchenz]

fix Sanjay's comments

[shchenz]

@spatel Hi Sanjay, I have made changes accordingly. Could you help to have another review. Thanks.

[spatel]

In D48754#1158271, @shchenz wrote:

@spatel Hi Sanjay, I have made changes accordingly. Could you help to have another review. Thanks.

Thanks for the changes. This looks mostly right, but I want to make sure we're testing everything properly. This is really several independent steps in 1 patch, so I'd like to reduce the risk of bugs by breaking it up.

1. Please separate the creation of isKnownNegation() into its own patch and use it from InstSimplify -> SimplifyAddInst(). I have added tests at rL336822, so that should be a very small patch. Improving InstSimplify helps several other passes, so that's a good patch independent of abs().
2. The changes in matchSelectPattern can be separated and tested using patterns that are optimized by InstCombiner::foldSPFofSPF(). We'll need to add some tests for that part. Let me know if it is not clear.
3. The canonicalization changes will be the last step and should be covered by the tests shown in this patch, but I think we're missing some cases where the code may have bugs.

llvm/lib/Analysis/ValueTracking.cpp

4640 ↗

(On Diff #154932)

cmpEqNegated -> CmpUsesNegatedOp ?

4672–4673 ↗

(On Diff #154932)

Would it be better to return {N}ABS(X) here rather than {N}ABS(-X)?

Why is it useful to return the negated operand as the input rather than the original operand X?

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

840 ↗

(On Diff #154932)

What happens if the subtract has other uses? We should have tests for that possibility.

[shchenz]

In D48754#1159009, @spatel wrote:

In D48754#1158271, @shchenz wrote:

@spatel Hi Sanjay, I have made changes accordingly. Could you help to have another review. Thanks.

Thanks for the changes. This looks mostly right, but I want to make sure we're testing everything properly. This is really several independent steps in 1 patch, so I'd like to reduce the risk of bugs by breaking it up.

1. Please separate the creation of isKnownNegation() into its own patch and use it from InstSimplify -> SimplifyAddInst(). I have added tests at rL336822, so that should be a very small patch. Improving InstSimplify helps several other passes, so that's a good patch independent of abs().
2. The changes in matchSelectPattern can be separated and tested using patterns that are optimized by InstCombiner::foldSPFofSPF(). We'll need to add some tests for that part. Let me know if it is not clear.
3. The canonicalization changes will be the last step and should be covered by the tests shown in this patch, but I think we're missing some cases where the code may have bugs.

@spatel Hi Sanjay, I have made patches for 1 & 2. But I am not very clear about 3. You mentioned the code may have bugs, could you give me some details? I saw your inline comment "What happens if the subtract has other uses", do you mean this one? In my opinion, RHS from matchSelectPattern() currently must be sub(0, X) or sub(A, B) (LHS = sub(B, A)). If I change RHS(TVal or FVal) to sub(0, LHS), I think there will be no impact for RHS(TVal or FVal) other users. yes, you are right, there should be some test cases for this scenario. Thanks.

[shchenz]

part 1 & 2 are done.
part 3: canonicalize abs pattern and fix code review comments

[spatel]

Please add a test like this (it will fail with the current patch):

define i32 @abs_canonical_9(i32 %a, i32 %b) {
  %tmp2 = sub i32 %b, %a
  %tmp1 = sub i32 %a, %b
  %cmp = icmp sgt i32 %tmp1, -1
  %abs = select i1 %cmp, i32 %tmp1, i32 %tmp2
  %add = add i32 %abs, %tmp2 ; increase use count for %tmp2.
  ret i32 %add
}

[spatel]

Actually, it will fail even without the extra use, so this is a minimal test:

define i32 @abs_canonical_9(i32 %a, i32 %b) {
  %tmp2 = sub i32 %b, %a
  %tmp1 = sub i32 %a, %b
  %cmp = icmp sgt i32 %tmp1, -1
  %abs = select i1 %cmp, i32 %tmp1, i32 %tmp2
  ret i32 %abs
}

We can not just replace operands without considering the order of the instructions. It would be better to create a new instruction with the IRBuilder, so we don't have to worry about this problem.

[spatel]

llvm/lib/Analysis/ValueTracking.cpp

4520 ↗

(On Diff #155622)

There is some white space difference in this file. It should not be included in this patch now.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

836 ↗

(On Diff #155622)

typo: canoical

[shchenz]

In D48754#1163459, @spatel wrote:

Actually, it will fail even without the extra use, so this is a minimal test:

define i32 @abs_canonical_9(i32 %a, i32 %b) {
  %tmp2 = sub i32 %b, %a
  %tmp1 = sub i32 %a, %b
  %cmp = icmp sgt i32 %tmp1, -1
  %abs = select i1 %cmp, i32 %tmp1, i32 %tmp2
  ret i32 %abs
}

We can not just replace operands without considering the order of the instructions. It would be better to create a new instruction with the IRBuilder, so we don't have to worry about this problem.

@spatel Hi Sanjay, Sorry about this. Seems this is a big mistake. I will do some study about IRBuilder and upload a new patch later. Thanks for your help.

llvm/lib/Analysis/ValueTracking.cpp

4520 ↗

(On Diff #155622)

Yes, I deleted two white spaces added in line 4629 by mistake in rL337143.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

836 ↗

(On Diff #155622)

I'll fix that.

[spatel]

In D48754#1163584, @shchenz wrote:

We can not just replace operands without considering the order of the instructions. It would be better to create a new instruction with the IRBuilder, so we don't have to worry about this problem.

@spatel Hi Sanjay, Sorry about this. Seems this is a big mistake. I will do some study about IRBuilder and upload a new patch later. Thanks for your help.

It's not too bad - see the code just above here in canonicalizeMinMaxWithConstant() for an example.

[shchenz]

fix Sanjay's comments

[shchenz]

rebase the patch

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

797–799 ↗

(On Diff #156969)

This comment is not accurate now. It should mention the possibility of a compare that uses the negated op. I'm not sure how many variants we can match now, but you can include that number if you know the answer.

819–820 ↗

(On Diff #156969)

Rephrase this as:
The compare may use the negated abs()/nabs() operand, or it may use negation in non-canonical form such as: sub A, B.

821–822 ↗

(On Diff #156969)

Indentation is not as expected.

838 ↗

(On Diff #156969)

This assert can be more specific? The sub must be with the specific operands of LHS reversed?

840 ↗

(On Diff #156969)

Use Builder.CreateNeg().

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

188–192 ↗

(On Diff #156969)

This is the extra-uses scenario that I was worried about. We have more instructions than we started with. We should not canonicalize if we can not have equal or less-than instructions from the transform.

344–349 ↗

(On Diff #156969)

Similar to above - we should not ever have more instructions than we started with.

[shchenz]

fix Sanjay's comments.

[shchenz]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

797–799 ↗

(On Diff #156969)

Maybe we want to add new pattern in isKnownNegation(), to avoid change the comments every time we change isKnownNegetion(), I don't use a accurate number. Hope this is ok.

838 ↗

(On Diff #156969)

The assert is added in previous patch which is directly changing operands of operator Sub. Since that is a wrong patch and we create new node for RHS, I delete this assert.

[spatel]

Thanks for all of the IR improvements - LGTM.

Note that the 2nd step of the larger proposal for abs() improvements is implemented in D49837.

llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp

canonicalizeMinMaxWithConstant(SelectInst &Sel, ICmpInst &Cmp,
   assert(Sel.getTrueValue() == RHS && Sel.getFalseValue() == LHS &&
          "Unexpected results from matchSelectPattern");
   Sel.setTrueValue(LHS);
   Sel.setFalseValue(RHS);
   Sel.swapProfMetadata();
   return &Sel;
 }
 
-/// There are 4 select variants for each of ABS/NABS (different compare
-/// constants, compare predicates, select operands). Canonicalize to 1 pattern.
+/// There are many select variants for each of ABS/NABS.
+/// In matchSelectPattern(), there are different compare constants, compare
+/// predicates/operands and select operands.
+/// In isKnownNegation(), there are different formats of negated operands.
+/// Canonicalize all these variants to 1 pattern.
 /// This makes CSE more likely.
 static Instruction *canonicalizeAbsNabs(SelectInst &Sel, ICmpInst &Cmp,
                                         InstCombiner::BuilderTy &Builder) {
   if (!Cmp.hasOneUse() || !isa<Constant>(Cmp.getOperand(1)))
     return nullptr;
 
   // Choose a sign-bit check for the compare (likely simpler for codegen).
   // ABS:  (X <s 0) ? -X : X
   // NABS: (X <s 0) ? X : -X
   Value *LHS, *RHS;
   SelectPatternFlavor SPF = matchSelectPattern(&Sel, LHS, RHS).Flavor;
   if (SPF != SelectPatternFlavor::SPF_ABS &&
       SPF != SelectPatternFlavor::SPF_NABS)
     return nullptr;
-  
-  // TODO: later canonicalization change will move this condition check.
-  // Without this check, following assert will be hit.
-  if (match(Cmp.getOperand(0), m_Sub(m_Value(), m_Value())))
-    return nullptr;
+  Value *TVal = Sel.getTrueValue();
+  Value *FVal = Sel.getFalseValue();
+  assert(isKnownNegation(TVal, FVal) &&
+         "Unexpected result from matchSelectPattern");
+
+  // The compare may use the negated abs()/nabs() operand, or it may use
+  // negation in non-canonical form such as: sub A, B.
+  bool CmpUsesNegatedOp = match(Cmp.getOperand(0), m_Neg(m_Specific(TVal))) ||
+                          match(Cmp.getOperand(0), m_Neg(m_Specific(FVal)));
+
+  bool CmpCanonicalized = !CmpUsesNegatedOp &&
+                          match(Cmp.getOperand(1), m_ZeroInt()) &&
+                          Cmp.getPredicate() == ICmpInst::ICMP_SLT;
+  bool RHSCanonicalized = match(RHS, m_Neg(m_Specific(LHS)));
 
   // Is this already canonical?
-  if (match(Cmp.getOperand(1), m_ZeroInt()) &&
-      Cmp.getPredicate() == ICmpInst::ICMP_SLT)
+  if (CmpCanonicalized && RHSCanonicalized)
     return nullptr;
 
-  // Create the canonical compare.
+  // If RHS is used by other instructions except compare and select, don't
+  // canonicalize it to not increase the instruction count.
+  if (!(RHS->hasOneUse() || (RHS->hasNUses(2) && CmpUsesNegatedOp)))
+    return nullptr;
+
+  // Create the canonical compare: icmp slt LHS 0.
+  if (!CmpCanonicalized) {
     Cmp.setPredicate(ICmpInst::ICMP_SLT);
     Cmp.setOperand(1, ConstantInt::getNullValue(Cmp.getOperand(0)->getType()));
+    if (CmpUsesNegatedOp)
+      Cmp.setOperand(0, LHS);
+  }
+
+  // Create the canonical RHS: RHS = sub (0, LHS).
+  if (!RHSCanonicalized) {
+    assert(RHS->hasOneUse() && "RHS use number is not right");
+    RHS = Builder.CreateNeg(LHS);
+    if (TVal == LHS) {
+      Sel.setFalseValue(RHS);
+      FVal = RHS;
+    } else {
+      Sel.setTrueValue(RHS);
+      TVal = RHS;
+    }
+  }
 
   // If the select operands do not change, we're done.
-  Value *TVal = Sel.getTrueValue();
-  Value *FVal = Sel.getFalseValue();
   if (SPF == SelectPatternFlavor::SPF_NABS) {
-    if (TVal == LHS && match(FVal, m_Neg(m_Specific(TVal))))
+    if (TVal == LHS)
       return &Sel;
-    assert(FVal == LHS && match(TVal, m_Neg(m_Specific(FVal))) &&
-           "Unexpected results from matchSelectPattern");
+    assert(FVal == LHS && "Unexpected results from matchSelectPattern");
   } else {
-    if (FVal == LHS && match(TVal, m_Neg(m_Specific(FVal))))
+    if (FVal == LHS)
       return &Sel;
-    assert(TVal == LHS && match(FVal, m_Neg(m_Specific(TVal))) &&
-           "Unexpected results from matchSelectPattern");
+    assert(TVal == LHS && "Unexpected results from matchSelectPattern");
   }
 
   // We are swapping the select operands, so swap the metadata too.
   Sel.setTrueValue(FVal);
   Sel.setFalseValue(TVal);
   Sel.swapProfMetadata();
   return &Sel;
 }

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

;
   %neg = sub i32 0, %conv
   %abs = select i1 %cmp, i32 %conv, i32 %neg
   ret i32 %abs
 }
 
 define i32 @abs_canonical_6(i32 %a, i32 %b) {
 ; CHECK-LABEL: @abs_canonical_6(
 ; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP1]], -1
-; CHECK-NEXT:    [[TMP2:%.*]] = sub i32 [[B]], [[A]]
-; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[TMP1]], i32 [[TMP2]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP1]], 0
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i32 0, [[TMP1]]
+; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[TMP2]], i32 [[TMP1]]
 ; CHECK-NEXT:    ret i32 [[ABS]]
 ;
   %tmp1 = sub i32 %a, %b
   %cmp = icmp sgt i32 %tmp1, -1
   %tmp2 = sub i32 %b, %a
   %abs = select i1 %cmp, i32 %tmp1, i32 %tmp2
   ret i32 %abs
 }
 
 define <2 x i8> @abs_canonical_7(<2 x i8> %a, <2 x i8 > %b) {
 ; CHECK-LABEL: @abs_canonical_7(
 ; CHECK-NEXT:    [[TMP1:%.*]] = sub <2 x i8> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i8> [[TMP1]], <i8 -1, i8 -1>
-; CHECK-NEXT:    [[TMP2:%.*]] = sub <2 x i8> [[B]], [[A]]
-; CHECK-NEXT:    [[ABS:%.*]] = select <2 x i1> [[CMP]], <2 x i8> [[TMP1]], <2 x i8> [[TMP2]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i8> [[TMP1]], zeroinitializer
+; CHECK-NEXT:    [[TMP2:%.*]] = sub <2 x i8> zeroinitializer, [[TMP1]]
+; CHECK-NEXT:    [[ABS:%.*]] = select <2 x i1> [[CMP]], <2 x i8> [[TMP2]], <2 x i8> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x i8> [[ABS]]
 ;
 
   %tmp1 = sub <2 x i8> %a, %b
   %cmp = icmp sgt <2 x i8> %tmp1, <i8 -1, i8 -1>
   %tmp2 = sub <2 x i8> %b, %a
   %abs = select <2 x i1> %cmp, <2 x i8> %tmp1, <2 x i8> %tmp2
   ret <2 x i8> %abs
 }
 
 define i32 @abs_canonical_8(i32 %a) {
 ; CHECK-LABEL: @abs_canonical_8(
 ; CHECK-NEXT:    [[TMP:%.*]] = sub i32 0, [[A:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP]], 0
-; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[A]], i32 [[TMP]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A]], 0
+; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[TMP]], i32 [[A]]
 ; CHECK-NEXT:    ret i32 [[ABS]]
 ;
   %tmp = sub i32 0, %a
   %cmp = icmp slt i32 %tmp, 0
   %abs = select i1 %cmp, i32 %a, i32 %tmp
   ret i32 %abs
 }
 
+define i32 @abs_canonical_9(i32 %a, i32 %b) {
+; CHECK-LABEL: @abs_canonical_9(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP1]], -1
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i32 [[B]], [[A]]
+; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[TMP1]], i32 [[TMP2]]
+; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[ABS]], [[TMP2]]
+; CHECK-NEXT:    ret i32 [[ADD]]
+;
+  %tmp1 = sub i32 %a, %b
+  %cmp = icmp sgt i32 %tmp1, -1
+  %tmp2 = sub i32 %b, %a
+  %abs = select i1 %cmp, i32 %tmp1, i32 %tmp2
+  %add = add i32 %abs, %tmp2 ; increase use count for %tmp2.
+  ret i32 %add
+}
+
+define i32 @abs_canonical_10(i32 %a, i32 %b) {
+; CHECK-LABEL: @abs_canonical_10(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP1]], 0
+; CHECK-NEXT:    [[NEGTMP:%.*]] = sub i32 0, [[TMP1]]
+; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[NEGTMP]], i32 [[TMP1]]
+; CHECK-NEXT:    ret i32 [[ABS]]
+;
+  %tmp2 = sub i32 %b, %a
+  %tmp1 = sub i32 %a, %b
+  %cmp = icmp sgt i32 %tmp1, -1
+  %abs = select i1 %cmp, i32 %tmp1, i32 %tmp2
+  ret i32 %abs
+}
+
 ; We have a canonical form of nabs to make CSE easier.
 
 define i8 @nabs_canonical_1(i8 %x) {
 ; CHECK-LABEL: @nabs_canonical_1(
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i8 [[X:%.*]], 0
 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[X]]
 ; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i8 [[X]], i8 [[NEG]]
 ; CHECK-NEXT:    ret i8 [[ABS]]
;
   %neg = sub i32 0, %conv
   %abs = select i1 %cmp, i32 %neg, i32 %conv
   ret i32 %abs
 }
 
 define i32 @nabs_canonical_6(i32 %a, i32 %b) {
 ; CHECK-LABEL: @nabs_canonical_6(
 ; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP1]], -1
-; CHECK-NEXT:    [[TMP2:%.*]] = sub i32 [[B]], [[A]]
-; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[TMP2]], i32 [[TMP1]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP1]], 0
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i32 0, [[TMP1]]
+; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[TMP1]], i32 [[TMP2]]
 ; CHECK-NEXT:    ret i32 [[ABS]]
 ;
   %tmp1 = sub i32 %a, %b
   %cmp = icmp sgt i32 %tmp1, -1
   %tmp2 = sub i32 %b, %a
   %abs = select i1 %cmp, i32 %tmp2, i32 %tmp1
   ret i32 %abs
 }
 
 define <2 x i8> @nabs_canonical_7(<2 x i8> %a, <2 x i8 > %b) {
 ; CHECK-LABEL: @nabs_canonical_7(
 ; CHECK-NEXT:    [[TMP1:%.*]] = sub <2 x i8> [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i8> [[TMP1]], <i8 -1, i8 -1>
-; CHECK-NEXT:    [[TMP2:%.*]] = sub <2 x i8> [[B]], [[A]]
-; CHECK-NEXT:    [[ABS:%.*]] = select <2 x i1> [[CMP]], <2 x i8> [[TMP2]], <2 x i8> [[TMP1]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i8> [[TMP1]], zeroinitializer
+; CHECK-NEXT:    [[TMP2:%.*]] = sub <2 x i8> zeroinitializer, [[TMP1]]
+; CHECK-NEXT:    [[ABS:%.*]] = select <2 x i1> [[CMP]], <2 x i8> [[TMP1]], <2 x i8> [[TMP2]]
 ; CHECK-NEXT:    ret <2 x i8> [[ABS]]
 ;
   %tmp1 = sub <2 x i8> %a, %b
   %cmp = icmp sgt <2 x i8> %tmp1, <i8 -1, i8 -1>
   %tmp2 = sub <2 x i8> %b, %a
   %abs = select <2 x i1> %cmp, <2 x i8> %tmp2, <2 x i8> %tmp1
   ret <2 x i8> %abs
 }
 
 define i32 @nabs_canonical_8(i32 %a) {
 ; CHECK-LABEL: @nabs_canonical_8(
 ; CHECK-NEXT:    [[TMP:%.*]] = sub i32 0, [[A:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP]], 0
-; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[TMP]], i32 [[A]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A]], 0
+; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[A]], i32 [[TMP]]
 ; CHECK-NEXT:    ret i32 [[ABS]]
 ;
   %tmp = sub i32 0, %a
   %cmp = icmp slt i32 %tmp, 0
   %abs = select i1 %cmp, i32 %tmp, i32 %a
   ret i32 %abs
 }
 
+define i32 @nabs_canonical_9(i32 %a, i32 %b) {
+; CHECK-LABEL: @nabs_canonical_9(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[TMP1]], -1
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i32 [[B]], [[A]]
+; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[TMP2]], i32 [[TMP1]]
+; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[TMP2]], [[ABS]]
+; CHECK-NEXT:    ret i32 [[ADD]]
+;
+  %tmp1 = sub i32 %a, %b
+  %cmp = icmp sgt i32 %tmp1, -1
+  %tmp2 = sub i32 %b, %a
+  %abs = select i1 %cmp, i32 %tmp2, i32 %tmp1
+  %add = add i32 %tmp2, %abs ; increase use count for %tmp2
+  ret i32 %add
+}
+
+define i32 @nabs_canonical_10(i32 %a, i32 %b) {
+; CHECK-LABEL: @nabs_canonical_10(
+; CHECK-NEXT:    [[TMP1:%.*]] = sub i32 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[TMP1]], 0
+; CHECK-NEXT:    [[NEGTMP:%.*]] = sub i32 0, [[TMP1]]
+; CHECK-NEXT:    [[ABS:%.*]] = select i1 [[CMP]], i32 [[TMP1]], i32 [[NEGTMP]]
+; CHECK-NEXT:    ret i32 [[ABS]]
+;
+  %tmp2 = sub i32 %b, %a
+  %tmp1 = sub i32 %a, %b
+  %cmp = icmp slt i32 %tmp1, 1
+  %abs = select i1 %cmp, i32 %tmp1, i32 %tmp2
+  ret i32 %abs
+}
+
 ; The following 5 tests use a shift+add+xor to implement abs():
 ; B = ashr i8 A, 7  -- smear the sign bit.
 ; xor (add A, B), B -- add -1 and flip bits if negative
 
 define i8 @shifty_abs_commute0(i8 %x) {
 ; CHECK-LABEL: @shifty_abs_commute0(
 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt i8 [[X:%.*]], 0
 ; CHECK-NEXT:    [[TMP2:%.*]] = sub i8 0, [[X]]

llvm/trunk/test/Transforms/InstCombine/abs_abs.ll

;
   %sub = sub nsw i32 0, %x
   %cond = select i1 %cmp, i32 %sub, i32 %x
   %cmp1 = icmp slt i32 %cond, 1
   %sub9 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %sub9, i32 %cond
   ret i32 %cond18
 }
 
-; abs(abs(-x)) -> abs(-x)
+; abs(abs(-x)) -> abs(-x) -> abs(x)
 define i32 @abs_abs_x17(i32 %x) {
 ; CHECK-LABEL: @abs_abs_x17(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw i32 0, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[SUB]], -1
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[X]], 0
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[SUB]], i32 [[X]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %sub = sub nsw i32 0, %x
   %cmp = icmp sgt i32 %sub, -1
   %cond = select i1 %cmp, i32 %sub, i32 %x
   %cmp1 = icmp sgt i32 %cond, -1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %cond, i32 %sub16
   ret i32 %cond18
 }
 
 ; abs(abs(x - y)) -> abs(x - y)
 define i32 @abs_abs_x18(i32 %x, i32 %y) {
 ; CHECK-LABEL: @abs_abs_x18(
 ; CHECK-NEXT:    [[A:%.*]] = sub nsw i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[B:%.*]] = sub nsw i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A]], -1
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[A]], i32 [[B]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A]], 0
+; CHECK-NEXT:    [[NEGA:%.*]] = sub i32 0, [[A]]
+; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[NEGA]], i32 [[A]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %a = sub nsw i32 %x, %y
   %b = sub nsw i32 %y, %x
   %cmp = icmp sgt i32 %a, -1
   %cond = select i1 %cmp, i32 %a, i32 %b
   %cmp1 = icmp sgt i32 %cond, -1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %cond, i32 %sub16
   ret i32 %cond18
 }
 
-; abs(abs(-x)) -> abs(-x)
+; abs(abs(-x)) -> abs(-x) -> abs(x)
 define <2 x i32> @abs_abs_x02_vec(<2 x i32> %x) {
 ; CHECK-LABEL: @abs_abs_x02_vec(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw <2 x i32> zeroinitializer, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[SUB]], <i32 -1, i32 -1> 
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[X]], zeroinitializer
 ; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[SUB]], <2 x i32> [[X]]
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %sub = sub nsw <2 x i32> zeroinitializer, %x
   %cmp = icmp sgt <2 x i32> %sub, <i32 -1, i32 -1>
   %cond = select <2 x i1> %cmp, <2 x i32> %sub, <2 x i32> %x
   %cmp1 = icmp sgt <2 x i32> %cond, <i32 -1, i32 -1>
   %sub16 = sub nsw <2 x i32> zeroinitializer, %cond
   %cond18 = select <2 x i1> %cmp1, <2 x i32> %cond, <2 x i32> %sub16
   ret <2 x i32> %cond18
 }
 
 ; abs(abs(x - y)) -> abs(x - y)
 define <2 x i32> @abs_abs_x03_vec(<2 x i32> %x, <2 x i32> %y) {
 ; CHECK-LABEL: @abs_abs_x03_vec(
 ; CHECK-NEXT:    [[A:%.*]] = sub nsw <2 x i32> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[B:%.*]] = sub nsw <2 x i32> [[Y:%.*]], [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[A]], <i32 -1, i32 -1>
-; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[A]], <2 x i32> [[B]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[A]], zeroinitializer
+; CHECK-NEXT:    [[NEGA:%.*]] = sub <2 x i32> zeroinitializer, [[A]]
+; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[NEGA]], <2 x i32> [[A]]
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %a = sub nsw <2 x i32> %x, %y
   %b = sub nsw <2 x i32> %y, %x
   %cmp = icmp sgt <2 x i32> %a, <i32 -1, i32 -1>
   %cond = select <2 x i1> %cmp, <2 x i32> %a, <2 x i32> %b
   %cmp1 = icmp sgt <2 x i32> %cond, <i32 -1, i32 -1>
   %sub16 = sub nsw <2 x i32> zeroinitializer, %cond
;
   %sub = sub nsw i32 0, %x
   %cond = select i1 %cmp, i32 %x, i32 %sub
   %cmp1 = icmp slt i32 %cond, 1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %cond, i32 %sub16
   ret i32 %cond18
 }
 
-; nabs(nabs(-x)) -> nabs(-x)
+; nabs(nabs(-x)) -> nabs(-x) -> nabs(x)
 define i32 @nabs_nabs_x17(i32 %x) {
 ; CHECK-LABEL: @nabs_nabs_x17(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw i32 0, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[SUB]], -1
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[X]], 0
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[X]], i32 [[SUB]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %sub = sub nsw i32 0, %x
   %cmp = icmp sgt i32 %sub, -1
   %cond = select i1 %cmp, i32 %x, i32 %sub
   %cmp1 = icmp sgt i32 %cond, -1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %sub16, i32 %cond
   ret i32 %cond18
 }
 
 ; nabs(nabs(x - y)) -> nabs(x - y)
 define i32 @nabs_nabs_x18(i32 %x, i32 %y) {
 ; CHECK-LABEL: @nabs_nabs_x18(
 ; CHECK-NEXT:    [[A:%.*]] = sub nsw i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[B:%.*]] = sub nsw i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A]], -1
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[B]], i32 [[A]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A]], 0
+; CHECK-NEXT:    [[NEGA:%.*]] = sub i32 0, [[A]]
+; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[A]], i32 [[NEGA]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %a = sub nsw i32 %x, %y
   %b = sub nsw i32 %y, %x
   %cmp = icmp sgt i32 %a, -1
   %cond = select i1 %cmp, i32 %b, i32 %a
   %cmp1 = icmp sgt i32 %cond, -1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %sub16, i32 %cond
   ret i32 %cond18
 }
 
-; nabs(nabs(-x)) -> nabs(-x)
+; nabs(nabs(-x)) -> nabs(-x) -> nabs(x)
 define <2 x i32> @nabs_nabs_x01_vec(<2 x i32> %x) {
 ; CHECK-LABEL: @nabs_nabs_x01_vec(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw <2 x i32> zeroinitializer, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[SUB]], <i32 -1, i32 -1>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[X]], zeroinitializer
 ; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[X]], <2 x i32> [[SUB]]
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %sub = sub nsw <2 x i32> zeroinitializer, %x
   %cmp = icmp sgt <2 x i32> %sub, <i32 -1, i32 -1>
   %cond = select <2 x i1> %cmp, <2 x i32> %x, <2 x i32> %sub
   %cmp1 = icmp sgt <2 x i32> %cond, <i32 -1, i32 -1>
   %sub16 = sub nsw <2 x i32> zeroinitializer, %cond
   %cond18 = select <2 x i1> %cmp1, <2 x i32> %sub16, <2 x i32> %cond
   ret <2 x i32> %cond18
 }
 
 ; nabs(nabs(x - y)) -> nabs(x - y)
 define <2 x i32> @nabs_nabs_x02_vec(<2 x i32> %x, <2 x i32> %y) {
 ; CHECK-LABEL: @nabs_nabs_x02_vec(
 ; CHECK-NEXT:    [[A:%.*]] = sub nsw <2 x i32> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[B:%.*]] = sub nsw <2 x i32> [[Y:%.*]], [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[A]], <i32 -1, i32 -1>
-; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[B]], <2 x i32> [[A]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[A]], zeroinitializer
+; CHECK-NEXT:    [[NEGA:%.*]] = sub <2 x i32> zeroinitializer, [[A]]
+; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[A]], <2 x i32> [[NEGA]]
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %a = sub nsw <2 x i32> %x, %y
   %b = sub nsw <2 x i32> %y, %x
   %cmp = icmp sgt <2 x i32> %a, <i32 -1, i32 -1>
   %cond = select <2 x i1> %cmp, <2 x i32> %b, <2 x i32> %a
   %cmp1 = icmp sgt <2 x i32> %cond, <i32 -1, i32 -1>
   %sub16 = sub nsw <2 x i32> zeroinitializer, %cond
;
   %sub = sub nsw i32 0, %x
   %cond = select i1 %cmp, i32 %x, i32 %sub
   %cmp1 = icmp slt i32 %cond, 1
   %sub9 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %sub9, i32 %cond
   ret i32 %cond18
 }
 
-; abs(nabs(-x)) -> abs(-x)
+; abs(nabs(-x)) -> abs(-x) -> abs(x)
 define i32 @abs_nabs_x17(i32 %x) {
 ; CHECK-LABEL: @abs_nabs_x17(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw i32 0, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[SUB]], -1
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[X]], 0
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[SUB]], i32 [[X]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %sub = sub nsw i32 0, %x
   %cmp = icmp sgt i32 %sub, -1
   %cond = select i1 %cmp, i32 %x, i32 %sub
   %cmp1 = icmp sgt i32 %cond, -1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %cond, i32 %sub16
   ret i32 %cond18
 }
 
 ; abs(nabs(x - y)) -> abs(x - y)
 define i32 @abs_nabs_x18(i32 %x, i32 %y) {
 ; CHECK-LABEL: @abs_nabs_x18(
 ; CHECK-NEXT:    [[A:%.*]] = sub nsw i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[B:%.*]] = sub nsw i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A]], -1
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[A]], i32 [[B]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A]], 0
+; CHECK-NEXT:    [[NEGA:%.*]] = sub i32 0, [[A]]
+; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[NEGA]], i32 [[A]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %a = sub nsw i32 %x, %y
   %b = sub nsw i32 %y, %x
   %cmp = icmp sgt i32 %a, -1
   %cond = select i1 %cmp, i32 %b, i32 %a
   %cmp1 = icmp sgt i32 %cond, -1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %cond, i32 %sub16
   ret i32 %cond18
 }
 
-; abs(nabs(-x)) -> abs(-x)
+; abs(nabs(-x)) -> abs(-x) -> abs(x)
 define <2 x i32> @abs_nabs_x01_vec(<2 x i32> %x) {
 ; CHECK-LABEL: @abs_nabs_x01_vec(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw <2 x i32> zeroinitializer, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[SUB]], <i32 -1, i32 -1>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[X]], zeroinitializer
 ; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[SUB]], <2 x i32> [[X]]
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %sub = sub nsw <2 x i32> zeroinitializer, %x
   %cmp = icmp sgt <2 x i32> %sub, <i32 -1, i32 -1>
   %cond = select <2 x i1> %cmp, <2 x i32> %x, <2 x i32> %sub
   %cmp1 = icmp sgt <2 x i32> %cond, <i32 -1, i32 -1>
   %sub16 = sub nsw <2 x i32> zeroinitializer, %cond
   %cond18 = select <2 x i1> %cmp1, <2 x i32> %cond, <2 x i32> %sub16
   ret <2 x i32> %cond18
 }
 
 ; abs(nabs(x - y)) -> abs(x - y)
 define <2 x i32> @abs_nabs_x02_vec(<2 x i32> %x, <2 x i32> %y) {
 ; CHECK-LABEL: @abs_nabs_x02_vec(
 ; CHECK-NEXT:    [[A:%.*]] = sub nsw <2 x i32> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[B:%.*]] = sub nsw <2 x i32> [[Y:%.*]], [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[A]], <i32 -1, i32 -1>
-; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[A]], <2 x i32> [[B]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[A]], zeroinitializer
+; CHECK-NEXT:    [[NEGA:%.*]] = sub <2 x i32> zeroinitializer, [[A]]
+; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[NEGA]], <2 x i32> [[A]]
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %a = sub nsw <2 x i32> %x, %y
   %b = sub nsw <2 x i32> %y, %x
   %cmp = icmp sgt <2 x i32> %a, <i32 -1, i32 -1>
   %cond = select <2 x i1> %cmp, <2 x i32> %b, <2 x i32> %a
   %cmp1 = icmp sgt <2 x i32> %cond, <i32 -1, i32 -1>
   %sub16 = sub nsw <2 x i32> zeroinitializer, %cond
;
   %sub = sub nsw i32 0, %x
   %cond = select i1 %cmp, i32 %sub, i32 %x
   %cmp1 = icmp slt i32 %cond, 1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %cond, i32 %sub16
   ret i32 %cond18
 }
 
-; nabs(abs(-x)) -> nabs(-x)
+; nabs(abs(-x)) -> nabs(-x) -> nabs(x)
 define i32 @nabs_abs_x17(i32 %x) {
 ; CHECK-LABEL: @nabs_abs_x17(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw i32 0, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[SUB]], -1
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[X]], 0
 ; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[X]], i32 [[SUB]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %sub = sub nsw i32 0, %x
   %cmp = icmp sgt i32 %sub, -1
   %cond = select i1 %cmp, i32 %sub, i32 %x
   %cmp1 = icmp sgt i32 %cond, -1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %sub16, i32 %cond
   ret i32 %cond18
 }
 
 ; nabs(abs(x - y)) -> nabs(x - y)
 define i32 @nabs_abs_x18(i32 %x, i32 %y) {
 ; CHECK-LABEL: @nabs_abs_x18(
 ; CHECK-NEXT:    [[A:%.*]] = sub nsw i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[B:%.*]] = sub nsw i32 [[Y]], [[X]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A]], -1
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[B]], i32 [[A]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[A]], 0
+; CHECK-NEXT:    [[NEGA:%.*]] = sub i32 0, [[A]]
+; CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i32 [[A]], i32 [[NEGA]]
 ; CHECK-NEXT:    ret i32 [[COND]]
 ;
   %a = sub nsw i32 %x, %y
   %b = sub nsw i32 %y, %x
   %cmp = icmp sgt i32 %a, -1
   %cond = select i1 %cmp, i32 %a, i32 %b
   %cmp1 = icmp sgt i32 %cond, -1
   %sub16 = sub nsw i32 0, %cond
   %cond18 = select i1 %cmp1, i32 %sub16, i32 %cond
   ret i32 %cond18
 }
 
-; nabs(abs(-x)) -> nabs(-x)
+; nabs(abs(-x)) -> nabs(-x) -> nabs(x)
 define <2 x i32> @nabs_abs_x01_vec(<2 x i32> %x) {
 ; CHECK-LABEL: @nabs_abs_x01_vec(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw <2 x i32> zeroinitializer, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[SUB]], <i32 -1, i32 -1>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[X]], zeroinitializer
 ; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[X]], <2 x i32> [[SUB]]
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %sub = sub nsw <2 x i32> zeroinitializer, %x
   %cmp = icmp sgt <2 x i32> %sub, <i32 -1, i32 -1>
   %cond = select <2 x i1> %cmp, <2 x i32> %sub, <2 x i32> %x
   %cmp1 = icmp sgt <2 x i32> %cond, <i32 -1, i32 -1>
   %sub16 = sub nsw <2 x i32> zeroinitializer, %cond
   %cond18 = select <2 x i1> %cmp1, <2 x i32> %sub16, <2 x i32> %cond
   ret <2 x i32> %cond18
 }
 
 ; nabs(abs(x - y)) -> nabs(x - y)
 define <2 x i32> @nabs_abs_x02_vec(<2 x i32> %x, <2 x i32> %y) {
 ; CHECK-LABEL: @nabs_abs_x02_vec(
 ; CHECK-NEXT:    [[A:%.*]] = sub nsw <2 x i32> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[B:%.*]] = sub nsw <2 x i32> [[Y:%.*]], [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[A]], <i32 -1, i32 -1>
-; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[B]], <2 x i32> [[A]]
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[A]], zeroinitializer
+; CHECK-NEXT:    [[NEGA:%.*]] = sub <2 x i32> zeroinitializer, [[A]]
+; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[A]], <2 x i32> [[NEGA]]
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %a = sub nsw <2 x i32> %x, %y
   %b = sub nsw <2 x i32> %y, %x
   %cmp = icmp sgt <2 x i32> %a, <i32 -1, i32 -1>
   %cond = select <2 x i1> %cmp, <2 x i32> %a, <2 x i32> %b
   %cmp1 = icmp sgt <2 x i32> %cond, <i32 -1, i32 -1>
   %sub16 = sub nsw <2 x i32> zeroinitializer, %cond
   %cond18 = select <2 x i1> %cmp1, <2 x i32> %sub16, <2 x i32> %cond
   ret <2 x i32> %cond18
 }

llvm/trunk/test/Transforms/InstCombine/icmp.ll

;
   %res = icmp eq <2 x i64> %cast, zeroinitializer
   ret <2 x i1> %res
 }
 
 ; fold (icmp pred (sub (0, X)) C1) for vec type
 define <2 x i32> @Op1Negated_Vec(<2 x i32> %x) {
 ; CHECK-LABEL: @Op1Negated_Vec(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw <2 x i32> zeroinitializer, [[X:%.*]]
-; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt <2 x i32> [[SUB]], <i32 -1, i32 -1>
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt <2 x i32> [[X]], zeroinitializer
 ; CHECK-NEXT:    [[COND:%.*]] = select <2 x i1> [[CMP]], <2 x i32> [[SUB]], <2 x i32> [[X]]
 ; CHECK-NEXT:    ret <2 x i32> [[COND]]
 ;
   %sub = sub nsw <2 x i32> zeroinitializer, %x
   %cmp = icmp sgt <2 x i32> %sub, <i32 -1, i32 -1>
   %cond = select <2 x i1> %cmp, <2 x i32> %sub, <2 x i32> %x
   ret <2 x i32> %cond
 }