Added a new transformation " (X + Y) - (X + Z) --> (Y - Z) "

[sonamkumari]

Summary

Hi All,

Submitted a patch related to subtraction optimization.

The optimization is :
(X + Y) - (X + Z) --> (Y - Z)

Please help in reviewing it.

Regards,
Sonam.

[majnemer]

This instcombine is definitely not needed. This sort of thing is best handled by reassociate. In fact, it already handles this case today:

~/llvm/Debug+Asserts/bin/opt -reassociate -instcombine t.ll -o - -S

define i32 @test45(i32 %x, i32 %y, i32 %z) {
  %sub = sub i32 %y, %z
  ret i32 %sub
}

[sonamkumari]

Hi David,

Thanks for pointing out the mistake and reviewing the patch.

Regards,
Sonam.

lib/Transforms/InstCombine/InstCombineAddSub.cpp

if (Op1->hasOneUse()) {
     Constant *C = nullptr;
     Constant *CI = nullptr;
 
     // (X - (Y - Z))  -->  (X + (Z - Y)).
     if (match(Op1, m_Sub(m_Value(Y), m_Value(Z))))
       return BinaryOperator::CreateAdd(Op0,
                                       Builder->CreateSub(Z, Y, Op1->getName()));
 
+    // (X + Y) - (X + Z) --> (Y - Z)
+    if (match(Op0, m_Add(m_Value(X), m_Value(Y))) &&
+        match(Op1, m_Add(m_Value(X), m_Value(Z))))
+      return BinaryOperator::CreateSub(Y, Z);
+
     // (X - (X & Y))   -->   (X & ~Y)
     //
     if (match(Op1, m_And(m_Value(Y), m_Specific(Op0))) ||
         match(Op1, m_And(m_Specific(Op0), m_Value(Y))))
       return BinaryOperator::CreateAnd(Op0,
                                   Builder->CreateNot(Y, Y->getName() + ".not"));
 
     // 0 - (X sdiv C)  -> (X sdiv -C)  provided the negation doesn't overflow.

test/Transforms/InstCombine/sub.ll

 
 define i32 @test44(i32 %x) {
   %sub = sub nsw i32 %x, 32768
   ret i32 %sub
 ; CHECK-LABEL: @test44(
 ; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 %x, -32768
 ; CHECK: ret i32 [[ADD]]
 }
+
+define i32 @test45(i32 %x, i32 %y, i32 %z) {
+ %add = add i32 %x, %y
+ %add1 = add i32 %x, %z
+ %sub = sub i32 %add, %add1
+ ret i32 %sub
+; CHECK-LABEL: @test45(
+; CHECK-NEXT: %sub = sub i32 %y, %z
+; CHECK-NEXT: ret i32 %sub
+}