From c087e20331c8a4c3b77d96a73588e80c06d89e3d Mon Sep 17 00:00:00 2001
From: Duncan Sands <baldrick@free.fr>
Date: Fri, 14 Jan 2011 15:26:10 +0000
Subject: [PATCH] Turn X-(X-Y) into Y.  According to my auto-simplifier this is
 the most common simplification present in fully optimized code (I think
 instcombine fails to transform some of these when "X-Y" has more than one
 use).  Fires here and there all over the test-suite, for example it
 eliminates 8 subtractions in the final IR for 445.gobmk, 2 subs in
 447.dealII, 2 in paq8p etc.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123442 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Analysis/InstructionSimplify.cpp             | 16 +++++++++++++++-
 .../InstSimplify/2010-12-20-Reassociate.ll       |  8 ++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp
index d5cf626e60f..1d4ff0fc9e0 100644
--- a/lib/Analysis/InstructionSimplify.cpp
+++ b/lib/Analysis/InstructionSimplify.cpp
@@ -593,11 +593,25 @@ static Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
       match(Op0, m_Add(m_Specific(Op1), m_Value(X))))
     return X;
 
-  /// i1 sub -> xor.
+  // i1 sub -> xor.
   if (MaxRecurse && Op0->getType()->isIntegerTy(1))
     if (Value *V = SimplifyXorInst(Op0, Op1, TD, DT, MaxRecurse-1))
       return V;
 
+  // X - (X - Y) -> Y.  More generally Z - (X - Y) -> (Z - X) + Y if everything
+  // simplifies.
+  Value *Y = 0, *Z = Op0;
+  if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y)
+    // See if "V === Z - X" simplifies.
+    if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, TD, DT, MaxRecurse-1))
+      // It does!  Now see if "W === V + Y" simplifies.
+      if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, TD, DT,
+                                   MaxRecurse-1)) {
+        // It does, we successfully reassociated!
+        ++NumReassoc;
+        return W;
+      }
+
   // Mul distributes over Sub.  Try some generic simplifications based on this.
   if (Value *V = FactorizeBinOp(Instruction::Sub, Op0, Op1, Instruction::Mul,
                                 TD, DT, MaxRecurse))
diff --git a/test/Transforms/InstSimplify/2010-12-20-Reassociate.ll b/test/Transforms/InstSimplify/2010-12-20-Reassociate.ll
index 87dfdda910b..03d5c33f872 100644
--- a/test/Transforms/InstSimplify/2010-12-20-Reassociate.ll
+++ b/test/Transforms/InstSimplify/2010-12-20-Reassociate.ll
@@ -62,3 +62,11 @@ define i32 @xor2(i32 %x, i32 %y) {
   ret i32 %l
 ; CHECK: ret i32 %y
 }
+
+define i32 @sub1(i32 %x, i32 %y) {
+; CHECK: @sub1
+  %d = sub i32 %x, %y
+  %r = sub i32 %x, %d
+  ret i32 %r
+; CHECK: ret i32 %y
+}