Make API commutatable

Author: goldsteinn

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

@@ -1521,8 +1521,11 @@ Instruction *InstCombinerImpl::visitAdd(BinaryOperator &I) {
     return R;
 
   Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
-  if (Instruction *R =
-          foldAddLike(LHS, RHS, I.hasNoSignedWrap(), I.hasNoUnsignedWrap()))
+  if (Instruction *R = foldAddLikeCommutative(LHS, RHS, I.hasNoSignedWrap(),
+                                              I.hasNoUnsignedWrap()))
+    return R;
+  if (Instruction *R = foldAddLikeCommutative(RHS, LHS, I.hasNoSignedWrap(),
+                                              I.hasNoUnsignedWrap()))
     return R;
   Type *Ty = I.getType();
   if (Ty->isIntOrIntVectorTy(1))

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

@@ -3580,10 +3580,16 @@ Instruction *InstCombinerImpl::visitOr(BinaryOperator &I) {
   if (Instruction *R = tryFoldInstWithCtpopWithNot(&I))
     return R;
 
-  if (cast<PossiblyDisjointInst>(I).isDisjoint())
-    if (Instruction *R = foldAddLike(I.getOperand(0), I.getOperand(1),
-                                     /*NSW=*/true, /*NUW=*/true))
+  if (cast<PossiblyDisjointInst>(I).isDisjoint()) {
+    if (Instruction *R =
+            foldAddLikeCommutative(I.getOperand(0), I.getOperand(1),
+                                   /*NSW=*/true, /*NUW=*/true))
+      return R;
+    if (Instruction *R =
+            foldAddLikeCommutative(I.getOperand(1), I.getOperand(0),
+                                   /*NSW=*/true, /*NUW=*/true))
       return R;
+  }
 
   Value *X, *Y;
   const APInt *CV;

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

@@ -586,7 +586,8 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
                                unsigned Depth = 0);
 
   /// Common transforms for add / disjoint or
-  Instruction *foldAddLike(Value *LHS, Value *RHS, bool NSW, bool NUW);
+  Instruction *foldAddLikeCommutative(Value *LHS, Value *RHS, bool NSW,
+                                      bool NUW);
 
   /// Canonicalize the position of binops relative to shufflevector.
   Instruction *foldVectorBinop(BinaryOperator &Inst);

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

@@ -2008,26 +2008,20 @@ static bool shouldMergeGEPs(GEPOperator &GEP, GEPOperator &Src) {
   return true;
 }
 
-Instruction *InstCombinerImpl::foldAddLike(Value *LHS, Value *RHS, bool NSW,
-                                           bool NUW) {
-  Value *A, *B, *C, *D;
+Instruction *InstCombinerImpl::foldAddLikeCommutative(Value *LHS, Value *RHS,
+                                                      bool NSW, bool NUW) {
+  Value *A, *B, *C;
   if (match(LHS, m_Sub(m_Value(A), m_Value(B))) &&
-      match(RHS, m_Sub(m_Value(C), m_Value(D)))) {
-    Instruction *R = nullptr;
-    if (A == D)
-      R = BinaryOperator::CreateSub(C, B);
-    else if (C == B)
-      R = BinaryOperator::CreateSub(A, D);
-    if (R) {
-      bool NSWOut = NSW && match(LHS, m_NSWSub(m_Value(), m_Value())) &&
-                    match(RHS, m_NSWSub(m_Value(), m_Value()));
-
-      bool NUWOut = match(LHS, m_NUWSub(m_Value(), m_Value())) &&
-                    match(RHS, m_NUWSub(m_Value(), m_Value()));
-      R->setHasNoSignedWrap(NSWOut);
-      R->setHasNoUnsignedWrap(NUWOut);
-      return R;
-    }
+      match(RHS, m_Sub(m_Value(C), m_Specific(A)))) {
+    Instruction *R = BinaryOperator::CreateSub(C, B);
+    bool NSWOut = NSW && match(LHS, m_NSWSub(m_Value(), m_Value())) &&
+                  match(RHS, m_NSWSub(m_Value(), m_Value()));
+
+    bool NUWOut = match(LHS, m_NUWSub(m_Value(), m_Value())) &&
+                  match(RHS, m_NUWSub(m_Value(), m_Value()));
+    R->setHasNoSignedWrap(NSWOut);
+    R->setHasNoUnsignedWrap(NUWOut);
+    return R;
   }
   return nullptr;
 }